YES 8.157 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ CR

mainModule List
  ((insert :: (Ord a, Ord b) => (b,a ->  [(b,a)]  ->  [(b,a)]) :: (Ord b, Ord a) => (b,a ->  [(b,a)]  ->  [(b,a)])

module List where
  import qualified Maybe
import qualified Prelude

  insert :: Ord a => a  ->  [a ->  [a]
insert e ls insertBy compare e ls

  insertBy :: (a  ->  a  ->  Ordering ->  a  ->  [a ->  [a]
insertBy x [] x : []
insertBy cmp x ys@(y : ys'
case cmp x y of
  GT-> y : insertBy cmp x ys'
  _-> x : ys


module Maybe where
  import qualified List
import qualified Prelude



Case Reductions:
The following Case expression
case cmp x y of
 GT → y : insertBy cmp x ys'
 _ → x : ys

is transformed to
insertBy0 y cmp x ys' ys GT = y : insertBy cmp x ys'
insertBy0 y cmp x ys' ys _ = x : ys

The following Case expression
case compare x y of
 EQ → o
 LT → LT
 GT → GT

is transformed to
primCompAux0 o EQ = o
primCompAux0 o LT = LT
primCompAux0 o GT = GT



↳ HASKELL
  ↳ CR
HASKELL
      ↳ IFR

mainModule List
  ((insert :: (Ord b, Ord a) => (a,b ->  [(a,b)]  ->  [(a,b)]) :: (Ord a, Ord b) => (a,b ->  [(a,b)]  ->  [(a,b)])

module List where
  import qualified Maybe
import qualified Prelude

  insert :: Ord a => a  ->  [a ->  [a]
insert e ls insertBy compare e ls

  insertBy :: (a  ->  a  ->  Ordering ->  a  ->  [a ->  [a]
insertBy x [] x : []
insertBy cmp x ys@(y : ys'insertBy0 y cmp x ys' ys (cmp x y)

  
insertBy0 y cmp x ys' ys GT y : insertBy cmp x ys'
insertBy0 y cmp x ys' ys _ x : ys


module Maybe where
  import qualified List
import qualified Prelude



If Reductions:
The following If expression
if primGEqNatS x y then Succ (primDivNatS (primMinusNatS x y) (Succ y)) else Zero

is transformed to
primDivNatS0 x y True = Succ (primDivNatS (primMinusNatS x y) (Succ y))
primDivNatS0 x y False = Zero

The following If expression
if primGEqNatS x y then primModNatS (primMinusNatS x y) (Succ y) else Succ x

is transformed to
primModNatS0 x y True = primModNatS (primMinusNatS x y) (Succ y)
primModNatS0 x y False = Succ x



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
HASKELL
          ↳ BR

mainModule List
  ((insert :: (Ord a, Ord b) => (b,a ->  [(b,a)]  ->  [(b,a)]) :: (Ord b, Ord a) => (b,a ->  [(b,a)]  ->  [(b,a)])

module List where
  import qualified Maybe
import qualified Prelude

  insert :: Ord a => a  ->  [a ->  [a]
insert e ls insertBy compare e ls

  insertBy :: (a  ->  a  ->  Ordering ->  a  ->  [a ->  [a]
insertBy x [] x : []
insertBy cmp x ys@(y : ys'insertBy0 y cmp x ys' ys (cmp x y)

  
insertBy0 y cmp x ys' ys GT y : insertBy cmp x ys'
insertBy0 y cmp x ys' ys _ x : ys


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.
Binding Reductions:
The bind variable of the following binding Pattern
ys@(vy : vz)

is replaced by the following term
vy : vz



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
HASKELL
              ↳ COR

mainModule List
  ((insert :: (Ord a, Ord b) => (b,a ->  [(b,a)]  ->  [(b,a)]) :: (Ord b, Ord a) => (b,a ->  [(b,a)]  ->  [(b,a)])

module List where
  import qualified Maybe
import qualified Prelude

  insert :: Ord a => a  ->  [a ->  [a]
insert e ls insertBy compare e ls

  insertBy :: (a  ->  a  ->  Ordering ->  a  ->  [a ->  [a]
insertBy vx x [] x : []
insertBy cmp x (vy : vzinsertBy0 vy cmp x vz (vy : vz) (cmp x vy)

  
insertBy0 y cmp x ys' ys GT y : insertBy cmp x ys'
insertBy0 y cmp x ys' ys vw x : ys


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
compare x y
 | x == y
 = EQ
 | x <= y
 = LT
 | otherwise
 = GT

is transformed to
compare x y = compare3 x y

compare0 x y True = GT

compare1 x y True = LT
compare1 x y False = compare0 x y otherwise

compare2 x y True = EQ
compare2 x y False = compare1 x y (x <= y)

compare3 x y = compare2 x y (x == y)

The following Function with conditions
gcd' x 0 = x
gcd' x y = gcd' y (x `rem` y)

is transformed to
gcd' x vuw = gcd'2 x vuw
gcd' x y = gcd'0 x y

gcd'0 x y = gcd' y (x `rem` y)

gcd'1 True x vuw = x
gcd'1 vux vuy vuz = gcd'0 vuy vuz

gcd'2 x vuw = gcd'1 (vuw == 0) x vuw
gcd'2 vvu vvv = gcd'0 vvu vvv

The following Function with conditions
gcd 0 0 = error []
gcd x y = 
gcd' (abs x) (abs y)
where 
gcd' x 0 = x
gcd' x y = gcd' y (x `rem` y)

is transformed to
gcd vvw vvx = gcd3 vvw vvx
gcd x y = gcd0 x y

gcd0 x y = 
gcd' (abs x) (abs y)
where 
gcd' x vuw = gcd'2 x vuw
gcd' x y = gcd'0 x y
gcd'0 x y = gcd' y (x `rem` y)
gcd'1 True x vuw = x
gcd'1 vux vuy vuz = gcd'0 vuy vuz
gcd'2 x vuw = gcd'1 (vuw == 0) x vuw
gcd'2 vvu vvv = gcd'0 vvu vvv

gcd1 True vvw vvx = error []
gcd1 vvy vvz vwu = gcd0 vvz vwu

gcd2 True vvw vvx = gcd1 (vvx == 0) vvw vvx
gcd2 vwv vww vwx = gcd0 vww vwx

gcd3 vvw vvx = gcd2 (vvw == 0) vvw vvx
gcd3 vwy vwz = gcd0 vwy vwz

The following Function with conditions
absReal x
 | x >= 0
 = x
 | otherwise
 = `negate` x

is transformed to
absReal x = absReal2 x

absReal1 x True = x
absReal1 x False = absReal0 x otherwise

absReal0 x True = `negate` x

absReal2 x = absReal1 x (x >= 0)

The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False

The following Function with conditions
reduce x y
 | y == 0
 = error []
 | otherwise
 = x `quot` d :% (y `quot` d)
where 
d  = gcd x y

is transformed to
reduce x y = reduce2 x y

reduce2 x y = 
reduce1 x y (y == 0)
where 
d  = gcd x y
reduce0 x y True = x `quot` d :% (y `quot` d)
reduce1 x y True = error []
reduce1 x y False = reduce0 x y otherwise



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
HASKELL
                  ↳ LetRed

mainModule List
  ((insert :: (Ord b, Ord a) => (a,b ->  [(a,b)]  ->  [(a,b)]) :: (Ord a, Ord b) => (a,b ->  [(a,b)]  ->  [(a,b)])

module List where
  import qualified Maybe
import qualified Prelude

  insert :: Ord a => a  ->  [a ->  [a]
insert e ls insertBy compare e ls

  insertBy :: (a  ->  a  ->  Ordering ->  a  ->  [a ->  [a]
insertBy vx x [] x : []
insertBy cmp x (vy : vzinsertBy0 vy cmp x vz (vy : vz) (cmp x vy)

  
insertBy0 y cmp x ys' ys GT y : insertBy cmp x ys'
insertBy0 y cmp x ys' ys vw x : ys


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
reduce1 x y (y == 0)
where 
d  = gcd x y
reduce0 x y True = x `quot` d :% (y `quot` d)
reduce1 x y True = error []
reduce1 x y False = reduce0 x y otherwise

are unpacked to the following functions on top level
reduce2D vxu vxv = gcd vxu vxv

reduce2Reduce1 vxu vxv x y True = error []
reduce2Reduce1 vxu vxv x y False = reduce2Reduce0 vxu vxv x y otherwise

reduce2Reduce0 vxu vxv x y True = x `quot` reduce2D vxu vxv :% (y `quot` reduce2D vxu vxv)

The bindings of the following Let/Where expression
gcd' (abs x) (abs y)
where 
gcd' x vuw = gcd'2 x vuw
gcd' x y = gcd'0 x y
gcd'0 x y = gcd' y (x `rem` y)
gcd'1 True x vuw = x
gcd'1 vux vuy vuz = gcd'0 vuy vuz
gcd'2 x vuw = gcd'1 (vuw == 0) x vuw
gcd'2 vvu vvv = gcd'0 vvu vvv

are unpacked to the following functions on top level
gcd0Gcd'1 True x vuw = x
gcd0Gcd'1 vux vuy vuz = gcd0Gcd'0 vuy vuz

gcd0Gcd' x vuw = gcd0Gcd'2 x vuw
gcd0Gcd' x y = gcd0Gcd'0 x y

gcd0Gcd'2 x vuw = gcd0Gcd'1 (vuw == 0) x vuw
gcd0Gcd'2 vvu vvv = gcd0Gcd'0 vvu vvv

gcd0Gcd'0 x y = gcd0Gcd' y (x `rem` y)



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
HASKELL
                      ↳ NumRed

mainModule List
  ((insert :: (Ord a, Ord b) => (b,a ->  [(b,a)]  ->  [(b,a)]) :: (Ord a, Ord b) => (b,a ->  [(b,a)]  ->  [(b,a)])

module List where
  import qualified Maybe
import qualified Prelude

  insert :: Ord a => a  ->  [a ->  [a]
insert e ls insertBy compare e ls

  insertBy :: (a  ->  a  ->  Ordering ->  a  ->  [a ->  [a]
insertBy vx x [] x : []
insertBy cmp x (vy : vzinsertBy0 vy cmp x vz (vy : vz) (cmp x vy)

  
insertBy0 y cmp x ys' ys GT y : insertBy cmp x ys'
insertBy0 y cmp x ys' ys vw x : ys


module Maybe where
  import qualified List
import qualified Prelude



Num Reduction: All numbers are transformed to thier corresponding representation with Pos, Neg, Succ and Zero.

↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
HASKELL
                          ↳ Narrow

mainModule List
  (insert :: (Ord a, Ord b) => (b,a ->  [(b,a)]  ->  [(b,a)])

module List where
  import qualified Maybe
import qualified Prelude

  insert :: Ord a => a  ->  [a ->  [a]
insert e ls insertBy compare e ls

  insertBy :: (a  ->  a  ->  Ordering ->  a  ->  [a ->  [a]
insertBy vx x [] x : []
insertBy cmp x (vy : vzinsertBy0 vy cmp x vz (vy : vz) (cmp x vy)

  
insertBy0 y cmp x ys' ys GT y : insertBy cmp x ys'
insertBy0 y cmp x ys' ys vw x : ys


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(vxw3100), Succ(vxw40100)) → new_primEqNat(vxw3100, vxw40100)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(vxw8400), Succ(vxw4010000)) → new_primPlusNat(vxw8400, vxw4010000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(vxw31000), Succ(vxw401000)) → new_primMulNat(vxw31000, Succ(vxw401000))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_primCmpNat(Succ(vxw2700), Succ(vxw2500)) → new_primCmpNat(vxw2700, vxw2500)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), app(app(ty_@2, cc), cd), ce) → new_esEs(vxw310, vxw4010, cc, cd)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), app(ty_[], cf), ce) → new_esEs0(vxw310, vxw4010, cf)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, app(ty_Maybe, baa), hg) → new_esEs1(vxw311, vxw4011, baa)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), app(ty_Maybe, bbb), gc, hg) → new_esEs1(vxw310, vxw4010, bbb)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), app(app(app(ty_@3, bbc), bbd), bbe), gc, hg) → new_esEs2(vxw310, vxw4010, bbc, bbd, bbe)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, gc, app(ty_[], gf)) → new_esEs0(vxw312, vxw4012, gf)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, app(app(ty_Either, bae), baf), hg) → new_esEs3(vxw311, vxw4011, bae, baf)
new_esEs3(Left(vxw310), Left(vxw4010), app(ty_Maybe, bcd), bcb) → new_esEs1(vxw310, vxw4010, bcd)
new_esEs0(:(vxw310, vxw311), :(vxw4010, vxw4011), app(app(app(ty_@3, ec), ed), ee)) → new_esEs2(vxw310, vxw4010, ec, ed, ee)
new_esEs1(Just(vxw310), Just(vxw4010), app(app(ty_@2, eh), fa)) → new_esEs(vxw310, vxw4010, eh, fa)
new_esEs3(Right(vxw310), Right(vxw4010), bdb, app(app(ty_Either, beb), bec)) → new_esEs3(vxw310, vxw4010, beb, bec)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), ba, app(ty_Maybe, be)) → new_esEs1(vxw311, vxw4011, be)
new_esEs1(Just(vxw310), Just(vxw4010), app(ty_[], fb)) → new_esEs0(vxw310, vxw4010, fb)
new_esEs3(Left(vxw310), Left(vxw4010), app(app(ty_Either, bch), bda), bcb) → new_esEs3(vxw310, vxw4010, bch, bda)
new_esEs3(Left(vxw310), Left(vxw4010), app(app(ty_@2, bbh), bca), bcb) → new_esEs(vxw310, vxw4010, bbh, bca)
new_esEs0(:(vxw310, vxw311), :(vxw4010, vxw4011), app(app(ty_Either, ef), eg)) → new_esEs3(vxw310, vxw4010, ef, eg)
new_esEs1(Just(vxw310), Just(vxw4010), app(app(ty_Either, fh), ga)) → new_esEs3(vxw310, vxw4010, fh, ga)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), ba, app(app(app(ty_@3, bf), bg), bh)) → new_esEs2(vxw311, vxw4011, bf, bg, bh)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), app(app(ty_Either, dd), de), ce) → new_esEs3(vxw310, vxw4010, dd, de)
new_esEs0(:(vxw310, vxw311), :(vxw4010, vxw4011), app(ty_Maybe, eb)) → new_esEs1(vxw310, vxw4010, eb)
new_esEs3(Left(vxw310), Left(vxw4010), app(ty_[], bcc), bcb) → new_esEs0(vxw310, vxw4010, bcc)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), ba, app(app(ty_Either, ca), cb)) → new_esEs3(vxw311, vxw4011, ca, cb)
new_esEs3(Right(vxw310), Right(vxw4010), bdb, app(ty_[], bde)) → new_esEs0(vxw310, vxw4010, bde)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), app(app(ty_Either, bbf), bbg), gc, hg) → new_esEs3(vxw310, vxw4010, bbf, bbg)
new_esEs3(Right(vxw310), Right(vxw4010), bdb, app(ty_Maybe, bdf)) → new_esEs1(vxw310, vxw4010, bdf)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, app(app(app(ty_@3, bab), bac), bad), hg) → new_esEs2(vxw311, vxw4011, bab, bac, bad)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), ba, app(ty_[], bd)) → new_esEs0(vxw311, vxw4011, bd)
new_esEs1(Just(vxw310), Just(vxw4010), app(ty_Maybe, fc)) → new_esEs1(vxw310, vxw4010, fc)
new_esEs3(Right(vxw310), Right(vxw4010), bdb, app(app(app(ty_@3, bdg), bdh), bea)) → new_esEs2(vxw310, vxw4010, bdg, bdh, bea)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, gc, app(ty_Maybe, gg)) → new_esEs1(vxw312, vxw4012, gg)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), ba, app(app(ty_@2, bb), bc)) → new_esEs(vxw311, vxw4011, bb, bc)
new_esEs1(Just(vxw310), Just(vxw4010), app(app(app(ty_@3, fd), ff), fg)) → new_esEs2(vxw310, vxw4010, fd, ff, fg)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), app(app(app(ty_@3, da), db), dc), ce) → new_esEs2(vxw310, vxw4010, da, db, dc)
new_esEs0(:(vxw310, vxw311), :(vxw4010, vxw4011), app(app(ty_@2, dg), dh)) → new_esEs(vxw310, vxw4010, dg, dh)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, app(app(ty_@2, he), hf), hg) → new_esEs(vxw311, vxw4011, he, hf)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), app(app(ty_@2, bag), bah), gc, hg) → new_esEs(vxw310, vxw4010, bag, bah)
new_esEs0(:(vxw310, vxw311), :(vxw4010, vxw4011), app(ty_[], ea)) → new_esEs0(vxw310, vxw4010, ea)
new_esEs3(Left(vxw310), Left(vxw4010), app(app(app(ty_@3, bce), bcf), bcg), bcb) → new_esEs2(vxw310, vxw4010, bce, bcf, bcg)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, gc, app(app(ty_Either, hc), hd)) → new_esEs3(vxw312, vxw4012, hc, hd)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, gc, app(app(ty_@2, gd), ge)) → new_esEs(vxw312, vxw4012, gd, ge)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), app(ty_[], bba), gc, hg) → new_esEs0(vxw310, vxw4010, bba)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, app(ty_[], hh), hg) → new_esEs0(vxw311, vxw4011, hh)
new_esEs2(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), gb, gc, app(app(app(ty_@3, gh), ha), hb)) → new_esEs2(vxw312, vxw4012, gh, ha, hb)
new_esEs0(:(vxw310, vxw311), :(vxw4010, vxw4011), df) → new_esEs0(vxw311, vxw4011, df)
new_esEs3(Right(vxw310), Right(vxw4010), bdb, app(app(ty_@2, bdc), bdd)) → new_esEs(vxw310, vxw4010, bdc, bdd)
new_esEs(@2(vxw310, vxw311), @2(vxw4010, vxw4011), app(ty_Maybe, cg), ce) → new_esEs1(vxw310, vxw4010, cg)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof
                              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_ltEs1(Left(vxw280), Left(vxw260), app(ty_[], fd), ff) → new_ltEs0(vxw280, vxw260, fd)
new_ltEs1(Left(vxw280), Left(vxw260), app(ty_Maybe, gc), ff) → new_ltEs2(vxw280, vxw260, gc)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, app(app(ty_Either, bdb), bdc), bbe) → new_lt1(vxw281, vxw261, bdb, bdc)
new_compare0(:(vxw270, vxw271), :(vxw250, vxw251), ba) → new_primCompAux(vxw270, vxw250, new_compare(vxw271, vxw251, ba), ba)
new_ltEs1(Left(vxw280), Left(vxw260), app(app(ty_Either, ga), gb), ff) → new_ltEs1(vxw280, vxw260, ga, gb)
new_ltEs1(Right(vxw280), Right(vxw260), gg, app(ty_Maybe, he)) → new_ltEs2(vxw280, vxw260, he)
new_lt3(vxw27, vxw25, bfb, bfc, bfd) → new_compare23(vxw27, vxw25, new_esEs7(vxw27, vxw25, bfb, bfc, bfd), bfb, bfc, bfd)
new_lt(:(vxw270, vxw271), :(vxw250, vxw251), ba) → new_primCompAux(vxw270, vxw250, new_compare(vxw271, vxw251, ba), ba)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, app(ty_[], bcg), bbe) → new_lt(vxw281, vxw261, bcg)
new_lt(:(vxw270, vxw271), :(vxw250, vxw251), ba) → new_compare0(vxw271, vxw251, ba)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), app(ty_[], bbc), bbd, bbe) → new_lt(vxw280, vxw260, bbc)
new_compare0(:(vxw270, vxw271), :(vxw250, vxw251), ba) → new_compare0(vxw271, vxw251, ba)
new_ltEs1(Right(vxw280), Right(vxw260), gg, app(app(app(ty_@3, hf), hg), hh)) → new_ltEs3(vxw280, vxw260, hf, hg, hh)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), dh, app(ty_Maybe, ef)) → new_ltEs2(vxw281, vxw261, ef)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), app(ty_Maybe, dd), cf) → new_lt2(vxw280, vxw260, dd)
new_compare2(vxw27, vxw25, fb, fc) → new_compare21(vxw27, vxw25, new_esEs5(vxw27, vxw25, fb, fc), fb, fc)
new_ltEs1(Left(vxw280), Left(vxw260), app(app(ty_@2, fg), fh), ff) → new_ltEs(vxw280, vxw260, fg, fh)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), app(app(app(ty_@3, de), df), dg), cf) → new_lt3(vxw280, vxw260, de, df, dg)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), dh, app(ty_[], ea)) → new_ltEs0(vxw281, vxw261, ea)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), app(app(ty_Either, bbh), bca), bbd, bbe) → new_lt1(vxw280, vxw260, bbh, bca)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), app(ty_Maybe, bcb), bbd, bbe) → new_lt2(vxw280, vxw260, bcb)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), app(app(ty_@2, bbf), bbg), bbd, bbe) → new_lt0(vxw280, vxw260, bbf, bbg)
new_ltEs1(Right(vxw280), Right(vxw260), gg, app(app(ty_@2, ha), hb)) → new_ltEs(vxw280, vxw260, ha, hb)
new_primCompAux(vxw270, vxw250, vxw72, app(ty_[], bb)) → new_compare0(vxw270, vxw250, bb)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, bbd, app(ty_Maybe, bee)) → new_ltEs2(vxw282, vxw262, bee)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, app(app(ty_@2, bch), bda), bbe) → new_lt0(vxw281, vxw261, bch, bda)
new_compare21(vxw27, vxw25, False, fb, fc) → new_ltEs1(vxw27, vxw25, fb, fc)
new_primCompAux(vxw270, vxw250, vxw72, app(app(ty_Either, be), bf)) → new_compare2(vxw270, vxw250, be, bf)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), app(ty_[], ce), cf) → new_lt(vxw280, vxw260, ce)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), app(app(ty_Either, db), dc), cf) → new_lt1(vxw280, vxw260, db, dc)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), dh, app(app(app(ty_@3, eg), eh), fa)) → new_ltEs3(vxw281, vxw261, eg, eh, fa)
new_lt0(vxw27, vxw25, cc, cd) → new_compare20(vxw27, vxw25, new_esEs4(vxw27, vxw25, cc, cd), cc, cd)
new_ltEs2(Just(vxw280), Just(vxw260), app(app(ty_Either, bae), baf)) → new_ltEs1(vxw280, vxw260, bae, baf)
new_compare20(vxw27, vxw25, False, cc, cd) → new_ltEs(vxw27, vxw25, cc, cd)
new_lt2(vxw27, vxw25, bfa) → new_compare22(vxw27, vxw25, new_esEs6(vxw27, vxw25, bfa), bfa)
new_ltEs2(Just(vxw280), Just(vxw260), app(app(app(ty_@3, bah), bba), bbb)) → new_ltEs3(vxw280, vxw260, bah, bba, bbb)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, bbd, app(app(ty_@2, bea), beb)) → new_ltEs(vxw282, vxw262, bea, beb)
new_compare22(vxw27, vxw25, False, bfa) → new_ltEs2(vxw27, vxw25, bfa)
new_ltEs0(vxw28, vxw26, baa) → new_compare0(vxw28, vxw26, baa)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, bbd, app(ty_[], bdh)) → new_ltEs0(vxw282, vxw262, bdh)
new_ltEs2(Just(vxw280), Just(vxw260), app(app(ty_@2, bac), bad)) → new_ltEs(vxw280, vxw260, bac, bad)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, bbd, app(app(app(ty_@3, bef), beg), beh)) → new_ltEs3(vxw282, vxw262, bef, beg, beh)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), app(app(ty_@2, cg), da), cf) → new_lt0(vxw280, vxw260, cg, da)
new_ltEs2(Just(vxw280), Just(vxw260), app(ty_Maybe, bag)) → new_ltEs2(vxw280, vxw260, bag)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), app(app(app(ty_@3, bcc), bcd), bce), bbd, bbe) → new_lt3(vxw280, vxw260, bcc, bcd, bce)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, bbd, app(app(ty_Either, bec), bed)) → new_ltEs1(vxw282, vxw262, bec, bed)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), dh, app(app(ty_@2, eb), ec)) → new_ltEs(vxw281, vxw261, eb, ec)
new_ltEs1(Right(vxw280), Right(vxw260), gg, app(app(ty_Either, hc), hd)) → new_ltEs1(vxw280, vxw260, hc, hd)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, app(app(app(ty_@3, bde), bdf), bdg), bbe) → new_lt3(vxw281, vxw261, bde, bdf, bdg)
new_ltEs2(Just(vxw280), Just(vxw260), app(ty_[], bab)) → new_ltEs0(vxw280, vxw260, bab)
new_lt1(vxw27, vxw25, fb, fc) → new_compare21(vxw27, vxw25, new_esEs5(vxw27, vxw25, fb, fc), fb, fc)
new_ltEs3(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, app(ty_Maybe, bdd), bbe) → new_lt2(vxw281, vxw261, bdd)
new_compare4(vxw27, vxw25, bfb, bfc, bfd) → new_compare23(vxw27, vxw25, new_esEs7(vxw27, vxw25, bfb, bfc, bfd), bfb, bfc, bfd)
new_ltEs(@2(vxw280, vxw281), @2(vxw260, vxw261), dh, app(app(ty_Either, ed), ee)) → new_ltEs1(vxw281, vxw261, ed, ee)
new_compare1(vxw27, vxw25, cc, cd) → new_compare20(vxw27, vxw25, new_esEs4(vxw27, vxw25, cc, cd), cc, cd)
new_primCompAux(vxw270, vxw250, vxw72, app(app(ty_@2, bc), bd)) → new_compare1(vxw270, vxw250, bc, bd)
new_ltEs1(Right(vxw280), Right(vxw260), gg, app(ty_[], gh)) → new_ltEs0(vxw280, vxw260, gh)
new_ltEs1(Left(vxw280), Left(vxw260), app(app(app(ty_@3, gd), ge), gf), ff) → new_ltEs3(vxw280, vxw260, gd, ge, gf)
new_compare3(vxw27, vxw25, bfa) → new_compare22(vxw27, vxw25, new_esEs6(vxw27, vxw25, bfa), bfa)
new_primCompAux(vxw270, vxw250, vxw72, app(ty_Maybe, bg)) → new_compare3(vxw270, vxw250, bg)
new_primCompAux(vxw270, vxw250, vxw72, app(app(app(ty_@3, bh), ca), cb)) → new_compare4(vxw270, vxw250, bh, ca, cb)
new_compare23(vxw27, vxw25, False, bfb, bfc, bfd) → new_ltEs3(vxw27, vxw25, bfb, bfc, bfd)

The TRS R consists of the following rules:

new_esEs23(vxw311, vxw4011, ty_Integer) → new_esEs13(vxw311, vxw4011)
new_esEs9(vxw310, vxw4010, ty_Char) → new_esEs11(vxw310, vxw4010)
new_esEs24(vxw310, vxw4010, app(app(ty_Either, cga), cgb)) → new_esEs5(vxw310, vxw4010, cga, cgb)
new_lt5(vxw27, vxw25, bfb, bfc, bfd) → new_esEs10(new_compare9(vxw27, vxw25, bfb, bfc, bfd), LT)
new_compare31(vxw270, vxw250, ty_@0) → new_compare7(vxw270, vxw250)
new_compare31(vxw270, vxw250, ty_Int) → new_compare6(vxw270, vxw250)
new_compare15(vxw27, vxw25, True, fb, fc) → LT
new_esEs23(vxw311, vxw4011, app(app(ty_Either, ceg), ceh)) → new_esEs5(vxw311, vxw4011, ceg, ceh)
new_esEs23(vxw311, vxw4011, app(app(ty_@2, cdg), cdh)) → new_esEs4(vxw311, vxw4011, cdg, cdh)
new_compare([], :(vxw250, vxw251), ba) → LT
new_esEs20(vxw310, vxw4010, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_esEs26(vxw280, vxw260, ty_Double) → new_esEs14(vxw280, vxw260)
new_ltEs10(vxw281, vxw261, ty_Char) → new_ltEs18(vxw281, vxw261)
new_ltEs15(vxw28, vxw26) → new_fsEs(new_compare5(vxw28, vxw26))
new_ltEs19(vxw282, vxw262, ty_Float) → new_ltEs11(vxw282, vxw262)
new_esEs9(vxw310, vxw4010, ty_Bool) → new_esEs19(vxw310, vxw4010)
new_ltEs5(Just(vxw280), Just(vxw260), app(app(app(ty_@3, bah), bba), bbb)) → new_ltEs17(vxw280, vxw260, bah, bba, bbb)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Char) → new_ltEs18(vxw280, vxw260)
new_compare31(vxw270, vxw250, ty_Ordering) → new_compare16(vxw270, vxw250)
new_compare31(vxw270, vxw250, app(app(app(ty_@3, bh), ca), cb)) → new_compare9(vxw270, vxw250, bh, ca, cb)
new_compare19(vxw27, vxw25, fb, fc) → new_compare25(vxw27, vxw25, new_esEs5(vxw27, vxw25, fb, fc), fb, fc)
new_esEs23(vxw311, vxw4011, ty_Float) → new_esEs16(vxw311, vxw4011)
new_ltEs19(vxw282, vxw262, app(ty_Ratio, cge)) → new_ltEs12(vxw282, vxw262, cge)
new_lt16(vxw27, vxw25, fb, fc) → new_esEs10(new_compare19(vxw27, vxw25, fb, fc), LT)
new_esEs21(vxw280, vxw260, ty_@0) → new_esEs17(vxw280, vxw260)
new_primMulNat0(Zero, Zero) → Zero
new_esEs21(vxw280, vxw260, ty_Int) → new_esEs12(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_compare(:(vxw270, vxw271), [], ba) → GT
new_esEs5(Right(vxw310), Right(vxw4010), dcb, ty_Float) → new_esEs16(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Bool) → new_esEs19(vxw310, vxw4010)
new_esEs25(vxw281, vxw261, app(app(ty_@2, bch), bda)) → new_esEs4(vxw281, vxw261, bch, bda)
new_compare24(vxw27, vxw25, False, bfa) → new_compare13(vxw27, vxw25, new_ltEs5(vxw27, vxw25, bfa), bfa)
new_ltEs16(False, True) → True
new_esEs18(:%(vxw310, vxw311), :%(vxw4010, vxw4011), daf) → new_asAs(new_esEs28(vxw310, vxw4010, daf), new_esEs27(vxw311, vxw4011, daf))
new_compare12(vxw27, vxw25) → new_compare27(vxw27, vxw25, new_esEs19(vxw27, vxw25))
new_esEs21(vxw280, vxw260, app(ty_[], ce)) → new_esEs15(vxw280, vxw260, ce)
new_esEs22(vxw312, vxw4012, ty_@0) → new_esEs17(vxw312, vxw4012)
new_esEs25(vxw281, vxw261, app(ty_Ratio, cgd)) → new_esEs18(vxw281, vxw261, cgd)
new_esEs21(vxw280, vxw260, ty_Integer) → new_esEs13(vxw280, vxw260)
new_lt9(vxw27, vxw25) → new_esEs10(new_compare16(vxw27, vxw25), LT)
new_compare10(:%(vxw270, vxw271), :%(vxw250, vxw251), ty_Integer) → new_compare11(new_sr0(vxw270, vxw251), new_sr0(vxw250, vxw271))
new_ltEs10(vxw281, vxw261, app(ty_[], ea)) → new_ltEs4(vxw281, vxw261, ea)
new_ltEs16(True, False) → False
new_lt10(vxw280, vxw260, ty_Integer) → new_lt12(vxw280, vxw260)
new_lt10(vxw280, vxw260, ty_@0) → new_lt4(vxw280, vxw260)
new_esEs26(vxw280, vxw260, ty_Ordering) → new_esEs10(vxw280, vxw260)
new_ltEs19(vxw282, vxw262, ty_Bool) → new_ltEs16(vxw282, vxw262)
new_lt20(vxw281, vxw261, ty_Double) → new_lt14(vxw281, vxw261)
new_lt19(vxw280, vxw260, app(ty_Ratio, cgc)) → new_lt6(vxw280, vxw260, cgc)
new_ltEs19(vxw282, vxw262, ty_@0) → new_ltEs7(vxw282, vxw262)
new_ltEs6(Left(vxw280), Left(vxw260), app(app(ty_Either, ga), gb), ff) → new_ltEs6(vxw280, vxw260, ga, gb)
new_ltEs5(Just(vxw280), Just(vxw260), ty_@0) → new_ltEs7(vxw280, vxw260)
new_esEs21(vxw280, vxw260, app(app(app(ty_@3, de), df), dg)) → new_esEs7(vxw280, vxw260, de, df, dg)
new_esEs22(vxw312, vxw4012, app(ty_Maybe, cch)) → new_esEs6(vxw312, vxw4012, cch)
new_ltEs10(vxw281, vxw261, app(app(app(ty_@3, eg), eh), fa)) → new_ltEs17(vxw281, vxw261, eg, eh, fa)
new_ltEs8(EQ, EQ) → True
new_esEs23(vxw311, vxw4011, ty_Ordering) → new_esEs10(vxw311, vxw4011)
new_esEs27(vxw311, vxw4011, ty_Integer) → new_esEs13(vxw311, vxw4011)
new_esEs9(vxw310, vxw4010, app(ty_[], bhc)) → new_esEs15(vxw310, vxw4010, bhc)
new_esEs8(vxw311, vxw4011, ty_Ordering) → new_esEs10(vxw311, vxw4011)
new_esEs25(vxw281, vxw261, ty_Double) → new_esEs14(vxw281, vxw261)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Float) → new_ltEs11(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, ty_@0) → new_esEs17(vxw310, vxw4010)
new_esEs9(vxw310, vxw4010, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Char, dag) → new_esEs11(vxw310, vxw4010)
new_esEs8(vxw311, vxw4011, app(ty_[], bga)) → new_esEs15(vxw311, vxw4011, bga)
new_lt20(vxw281, vxw261, app(ty_[], bcg)) → new_lt13(vxw281, vxw261, bcg)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, ty_@0) → new_esEs17(vxw310, vxw4010)
new_lt7(vxw27, vxw25) → new_esEs10(new_compare12(vxw27, vxw25), LT)
new_esEs8(vxw311, vxw4011, app(app(ty_@2, bfg), bfh)) → new_esEs4(vxw311, vxw4011, bfg, bfh)
new_esEs22(vxw312, vxw4012, app(ty_Ratio, cda)) → new_esEs18(vxw312, vxw4012, cda)
new_compare30(vxw27, vxw25, cc, cd) → new_compare210(vxw27, vxw25, new_esEs4(vxw27, vxw25, cc, cd), cc, cd)
new_ltEs16(True, True) → True
new_ltEs19(vxw282, vxw262, ty_Char) → new_ltEs18(vxw282, vxw262)
new_esEs17(@0, @0) → True
new_ltEs6(Left(vxw280), Left(vxw260), ty_Double, ff) → new_ltEs15(vxw280, vxw260)
new_esEs5(Left(vxw310), Left(vxw4010), app(ty_Maybe, dbc), dag) → new_esEs6(vxw310, vxw4010, dbc)
new_pePe(False, vxw63) → vxw63
new_lt10(vxw280, vxw260, app(ty_[], ce)) → new_lt13(vxw280, vxw260, ce)
new_esEs25(vxw281, vxw261, ty_Char) → new_esEs11(vxw281, vxw261)
new_lt6(vxw27, vxw25, cac) → new_esEs10(new_compare10(vxw27, vxw25, cac), LT)
new_compare31(vxw270, vxw250, ty_Float) → new_compare32(vxw270, vxw250)
new_ltEs6(Right(vxw280), Right(vxw260), gg, app(ty_Maybe, he)) → new_ltEs5(vxw280, vxw260, he)
new_lt19(vxw280, vxw260, ty_Ordering) → new_lt9(vxw280, vxw260)
new_esEs8(vxw311, vxw4011, ty_Float) → new_esEs16(vxw311, vxw4011)
new_esEs8(vxw311, vxw4011, ty_@0) → new_esEs17(vxw311, vxw4011)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Int, ff) → new_ltEs14(vxw280, vxw260)
new_ltEs4(vxw28, vxw26, baa) → new_fsEs(new_compare(vxw28, vxw26, baa))
new_esEs22(vxw312, vxw4012, app(app(ty_@2, cce), ccf)) → new_esEs4(vxw312, vxw4012, cce, ccf)
new_lt10(vxw280, vxw260, ty_Char) → new_lt18(vxw280, vxw260)
new_esEs20(vxw310, vxw4010, ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_ltEs8(EQ, GT) → True
new_ltEs8(GT, GT) → True
new_ltEs6(Right(vxw280), Right(vxw260), gg, ty_Integer) → new_ltEs13(vxw280, vxw260)
new_compare9(vxw27, vxw25, bfb, bfc, bfd) → new_compare28(vxw27, vxw25, new_esEs7(vxw27, vxw25, bfb, bfc, bfd), bfb, bfc, bfd)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, app(app(ty_@2, dcc), dcd)) → new_esEs4(vxw310, vxw4010, dcc, dcd)
new_esEs23(vxw311, vxw4011, ty_Double) → new_esEs14(vxw311, vxw4011)
new_esEs23(vxw311, vxw4011, app(app(app(ty_@3, ced), cee), cef)) → new_esEs7(vxw311, vxw4011, ced, cee, cef)
new_primCmpNat0(Zero, Succ(vxw2500)) → LT
new_ltEs5(Just(vxw280), Just(vxw260), app(ty_Ratio, cgg)) → new_ltEs12(vxw280, vxw260, cgg)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Char, ff) → new_ltEs18(vxw280, vxw260)
new_esEs25(vxw281, vxw261, app(app(ty_Either, bdb), bdc)) → new_esEs5(vxw281, vxw261, bdb, bdc)
new_ltEs5(Just(vxw280), Just(vxw260), app(app(ty_Either, bae), baf)) → new_ltEs6(vxw280, vxw260, bae, baf)
new_ltEs10(vxw281, vxw261, ty_Double) → new_ltEs15(vxw281, vxw261)
new_ltEs8(LT, EQ) → True
new_esEs24(vxw310, vxw4010, ty_Int) → new_esEs12(vxw310, vxw4010)
new_esEs10(LT, LT) → True
new_esEs10(GT, EQ) → False
new_esEs10(EQ, GT) → False
new_lt10(vxw280, vxw260, app(app(ty_@2, cg), da)) → new_lt15(vxw280, vxw260, cg, da)
new_pePe(True, vxw63) → True
new_primEqNat0(Zero, Zero) → True
new_compare14(vxw27, vxw25, False, cc, cd) → GT
new_esEs6(Just(vxw310), Just(vxw4010), app(app(app(ty_@3, daa), dab), dac)) → new_esEs7(vxw310, vxw4010, daa, dab, dac)
new_compare26(vxw27, vxw25, True) → EQ
new_lt10(vxw280, vxw260, ty_Float) → new_lt11(vxw280, vxw260)
new_esEs26(vxw280, vxw260, app(ty_Maybe, bcb)) → new_esEs6(vxw280, vxw260, bcb)
new_compare28(vxw27, vxw25, False, bfb, bfc, bfd) → new_compare110(vxw27, vxw25, new_ltEs17(vxw27, vxw25, bfb, bfc, bfd), bfb, bfc, bfd)
new_ltEs19(vxw282, vxw262, app(ty_[], bdh)) → new_ltEs4(vxw282, vxw262, bdh)
new_esEs9(vxw310, vxw4010, app(ty_Maybe, bhd)) → new_esEs6(vxw310, vxw4010, bhd)
new_lt20(vxw281, vxw261, ty_Bool) → new_lt7(vxw281, vxw261)
new_esEs19(True, True) → True
new_esEs6(Just(vxw310), Just(vxw4010), ty_Double) → new_esEs14(vxw310, vxw4010)
new_esEs9(vxw310, vxw4010, ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_ltEs8(GT, EQ) → False
new_ltEs8(EQ, LT) → False
new_compare(:(vxw270, vxw271), :(vxw250, vxw251), ba) → new_primCompAux1(vxw270, vxw250, new_compare(vxw271, vxw251, ba), ba)
new_sr(vxw310, vxw4010) → new_primMulInt(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), ty_@0) → new_esEs17(vxw310, vxw4010)
new_esEs25(vxw281, vxw261, app(ty_[], bcg)) → new_esEs15(vxw281, vxw261, bcg)
new_lt19(vxw280, vxw260, ty_Int) → new_lt8(vxw280, vxw260)
new_esEs9(vxw310, vxw4010, app(app(app(ty_@3, bhf), bhg), bhh)) → new_esEs7(vxw310, vxw4010, bhf, bhg, bhh)
new_esEs23(vxw311, vxw4011, app(ty_[], cea)) → new_esEs15(vxw311, vxw4011, cea)
new_esEs26(vxw280, vxw260, ty_Int) → new_esEs12(vxw280, vxw260)
new_lt11(vxw27, vxw25) → new_esEs10(new_compare32(vxw27, vxw25), LT)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, app(ty_Ratio, dcg)) → new_esEs18(vxw310, vxw4010, dcg)
new_primPlusNat0(Succ(vxw840), vxw401000) → Succ(Succ(new_primPlusNat1(vxw840, vxw401000)))
new_lt17(vxw27, vxw25, bfa) → new_esEs10(new_compare29(vxw27, vxw25, bfa), LT)
new_esEs25(vxw281, vxw261, ty_Float) → new_esEs16(vxw281, vxw261)
new_lt19(vxw280, vxw260, ty_@0) → new_lt4(vxw280, vxw260)
new_compare31(vxw270, vxw250, app(ty_Maybe, bg)) → new_compare29(vxw270, vxw250, bg)
new_esEs20(vxw310, vxw4010, app(app(app(ty_@3, cbb), cbc), cbd)) → new_esEs7(vxw310, vxw4010, cbb, cbc, cbd)
new_esEs23(vxw311, vxw4011, ty_Int) → new_esEs12(vxw311, vxw4011)
new_esEs13(Integer(vxw310), Integer(vxw4010)) → new_primEqInt(vxw310, vxw4010)
new_ltEs6(Left(vxw280), Left(vxw260), app(app(app(ty_@3, gd), ge), gf), ff) → new_ltEs17(vxw280, vxw260, gd, ge, gf)
new_lt20(vxw281, vxw261, ty_Ordering) → new_lt9(vxw281, vxw261)
new_primEqInt(Neg(Succ(vxw3100)), Neg(Succ(vxw40100))) → new_primEqNat0(vxw3100, vxw40100)
new_esEs10(EQ, EQ) → True
new_lt15(vxw27, vxw25, cc, cd) → new_esEs10(new_compare30(vxw27, vxw25, cc, cd), LT)
new_ltEs14(vxw28, vxw26) → new_fsEs(new_compare6(vxw28, vxw26))
new_ltEs19(vxw282, vxw262, ty_Ordering) → new_ltEs8(vxw282, vxw262)
new_ltEs5(Just(vxw280), Nothing, cgf) → False
new_primPlusNat1(Succ(vxw8400), Zero) → Succ(vxw8400)
new_primPlusNat1(Zero, Succ(vxw4010000)) → Succ(vxw4010000)
new_esEs21(vxw280, vxw260, ty_Ordering) → new_esEs10(vxw280, vxw260)
new_lt19(vxw280, vxw260, ty_Bool) → new_lt7(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, ty_Bool) → new_esEs19(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Integer) → new_esEs13(vxw310, vxw4010)
new_ltEs6(Right(vxw280), Right(vxw260), gg, app(app(ty_@2, ha), hb)) → new_ltEs9(vxw280, vxw260, ha, hb)
new_esEs26(vxw280, vxw260, app(app(app(ty_@3, bcc), bcd), bce)) → new_esEs7(vxw280, vxw260, bcc, bcd, bce)
new_compare27(vxw27, vxw25, False) → new_compare18(vxw27, vxw25, new_ltEs16(vxw27, vxw25))
new_ltEs10(vxw281, vxw261, app(ty_Ratio, cbh)) → new_ltEs12(vxw281, vxw261, cbh)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Integer, ff) → new_ltEs13(vxw280, vxw260)
new_compare29(vxw27, vxw25, bfa) → new_compare24(vxw27, vxw25, new_esEs6(vxw27, vxw25, bfa), bfa)
new_lt10(vxw280, vxw260, ty_Bool) → new_lt7(vxw280, vxw260)
new_esEs21(vxw280, vxw260, ty_Double) → new_esEs14(vxw280, vxw260)
new_primEqInt(Neg(Zero), Neg(Zero)) → True
new_esEs5(Left(vxw310), Left(vxw4010), app(app(app(ty_@3, dbe), dbf), dbg), dag) → new_esEs7(vxw310, vxw4010, dbe, dbf, dbg)
new_esEs19(False, False) → True
new_esEs27(vxw311, vxw4011, ty_Int) → new_esEs12(vxw311, vxw4011)
new_esEs23(vxw311, vxw4011, ty_Char) → new_esEs11(vxw311, vxw4011)
new_compare31(vxw270, vxw250, ty_Integer) → new_compare11(vxw270, vxw250)
new_ltEs6(Right(vxw280), Right(vxw260), gg, app(ty_Ratio, cha)) → new_ltEs12(vxw280, vxw260, cha)
new_lt19(vxw280, vxw260, ty_Integer) → new_lt12(vxw280, vxw260)
new_compare18(vxw27, vxw25, False) → GT
new_esEs9(vxw310, vxw4010, ty_Int) → new_esEs12(vxw310, vxw4010)
new_primEqInt(Neg(Zero), Neg(Succ(vxw40100))) → False
new_primEqInt(Neg(Succ(vxw3100)), Neg(Zero)) → False
new_primCompAux0(vxw77, GT) → GT
new_esEs5(Left(vxw310), Left(vxw4010), ty_Double, dag) → new_esEs14(vxw310, vxw4010)
new_ltEs19(vxw282, vxw262, ty_Int) → new_ltEs14(vxw282, vxw262)
new_esEs4(@2(vxw310, vxw311), @2(vxw4010, vxw4011), bfe, bff) → new_asAs(new_esEs9(vxw310, vxw4010, bfe), new_esEs8(vxw311, vxw4011, bff))
new_ltEs12(vxw28, vxw26, cca) → new_fsEs(new_compare10(vxw28, vxw26, cca))
new_esEs20(vxw310, vxw4010, ty_@0) → new_esEs17(vxw310, vxw4010)
new_esEs22(vxw312, vxw4012, ty_Int) → new_esEs12(vxw312, vxw4012)
new_compare([], [], ba) → EQ
new_lt19(vxw280, vxw260, ty_Float) → new_lt11(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_lt20(vxw281, vxw261, ty_Int) → new_lt8(vxw281, vxw261)
new_esEs8(vxw311, vxw4011, ty_Int) → new_esEs12(vxw311, vxw4011)
new_compare6(vxw27, vxw25) → new_primCmpInt(vxw27, vxw25)
new_esEs25(vxw281, vxw261, ty_@0) → new_esEs17(vxw281, vxw261)
new_primCmpNat0(Succ(vxw2700), Succ(vxw2500)) → new_primCmpNat0(vxw2700, vxw2500)
new_lt19(vxw280, vxw260, app(app(ty_Either, bbh), bca)) → new_lt16(vxw280, vxw260, bbh, bca)
new_esEs6(Nothing, Nothing, chc) → True
new_primEqInt(Pos(Succ(vxw3100)), Pos(Succ(vxw40100))) → new_primEqNat0(vxw3100, vxw40100)
new_compare210(vxw27, vxw25, False, cc, cd) → new_compare14(vxw27, vxw25, new_ltEs9(vxw27, vxw25, cc, cd), cc, cd)
new_lt18(vxw27, vxw25) → new_esEs10(new_compare8(vxw27, vxw25), LT)
new_esEs21(vxw280, vxw260, app(ty_Maybe, dd)) → new_esEs6(vxw280, vxw260, dd)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Integer) → new_ltEs13(vxw280, vxw260)
new_esEs26(vxw280, vxw260, ty_Bool) → new_esEs19(vxw280, vxw260)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, app(app(ty_Either, ddc), ddd)) → new_esEs5(vxw310, vxw4010, ddc, ddd)
new_esEs6(Nothing, Just(vxw4010), chc) → False
new_esEs6(Just(vxw310), Nothing, chc) → False
new_primEqNat0(Succ(vxw3100), Succ(vxw40100)) → new_primEqNat0(vxw3100, vxw40100)
new_compare7(@0, @0) → EQ
new_esEs24(vxw310, vxw4010, app(ty_Ratio, cfe)) → new_esEs18(vxw310, vxw4010, cfe)
new_esEs9(vxw310, vxw4010, ty_Float) → new_esEs16(vxw310, vxw4010)
new_ltEs5(Just(vxw280), Just(vxw260), app(app(ty_@2, bac), bad)) → new_ltEs9(vxw280, vxw260, bac, bad)
new_esEs20(vxw310, vxw4010, ty_Double) → new_esEs14(vxw310, vxw4010)
new_esEs8(vxw311, vxw4011, ty_Double) → new_esEs14(vxw311, vxw4011)
new_lt19(vxw280, vxw260, app(ty_[], bbc)) → new_lt13(vxw280, vxw260, bbc)
new_lt20(vxw281, vxw261, ty_@0) → new_lt4(vxw281, vxw261)
new_primCmpInt(Neg(Succ(vxw2700)), Neg(vxw250)) → new_primCmpNat0(vxw250, Succ(vxw2700))
new_esEs26(vxw280, vxw260, app(app(ty_@2, bbf), bbg)) → new_esEs4(vxw280, vxw260, bbf, bbg)
new_ltEs6(Left(vxw280), Right(vxw260), gg, ff) → True
new_ltEs6(Right(vxw280), Left(vxw260), gg, ff) → False
new_esEs15([], [], cad) → True
new_primEqInt(Pos(Zero), Pos(Succ(vxw40100))) → False
new_primEqInt(Pos(Succ(vxw3100)), Pos(Zero)) → False
new_ltEs5(Nothing, Just(vxw260), cgf) → True
new_ltEs10(vxw281, vxw261, app(app(ty_@2, eb), ec)) → new_ltEs9(vxw281, vxw261, eb, ec)
new_esEs22(vxw312, vxw4012, ty_Integer) → new_esEs13(vxw312, vxw4012)
new_lt13(vxw27, vxw25, ba) → new_esEs10(new_compare(vxw27, vxw25, ba), LT)
new_ltEs6(Right(vxw280), Right(vxw260), gg, app(app(app(ty_@3, hf), hg), hh)) → new_ltEs17(vxw280, vxw260, hf, hg, hh)
new_lt20(vxw281, vxw261, ty_Char) → new_lt18(vxw281, vxw261)
new_compare13(vxw27, vxw25, True, bfa) → LT
new_esEs21(vxw280, vxw260, ty_Bool) → new_esEs19(vxw280, vxw260)
new_esEs23(vxw311, vxw4011, ty_@0) → new_esEs17(vxw311, vxw4011)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(vxw2700), Zero) → GT
new_ltEs6(Left(vxw280), Left(vxw260), ty_@0, ff) → new_ltEs7(vxw280, vxw260)
new_compare18(vxw27, vxw25, True) → LT
new_lt20(vxw281, vxw261, app(ty_Ratio, cgd)) → new_lt6(vxw281, vxw261, cgd)
new_primCmpInt(Neg(Zero), Pos(Succ(vxw2500))) → LT
new_esEs19(True, False) → False
new_esEs19(False, True) → False
new_esEs20(vxw310, vxw4010, app(app(ty_Either, cbe), cbf)) → new_esEs5(vxw310, vxw4010, cbe, cbf)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, ty_Bool) → new_esEs19(vxw310, vxw4010)
new_sr0(Integer(vxw2700), Integer(vxw2510)) → Integer(new_primMulInt(vxw2700, vxw2510))
new_primPlusNat1(Succ(vxw8400), Succ(vxw4010000)) → Succ(Succ(new_primPlusNat1(vxw8400, vxw4010000)))
new_primEqInt(Neg(Succ(vxw3100)), Pos(vxw4010)) → False
new_primEqInt(Pos(Succ(vxw3100)), Neg(vxw4010)) → False
new_esEs5(Left(vxw310), Left(vxw4010), app(ty_Ratio, dbd), dag) → new_esEs18(vxw310, vxw4010, dbd)
new_esEs25(vxw281, vxw261, ty_Bool) → new_esEs19(vxw281, vxw261)
new_esEs24(vxw310, vxw4010, app(app(ty_@2, cfa), cfb)) → new_esEs4(vxw310, vxw4010, cfa, cfb)
new_esEs8(vxw311, vxw4011, app(app(ty_Either, bgg), bgh)) → new_esEs5(vxw311, vxw4011, bgg, bgh)
new_fsEs(vxw64) → new_not(new_esEs10(vxw64, GT))
new_esEs6(Just(vxw310), Just(vxw4010), ty_Char) → new_esEs11(vxw310, vxw4010)
new_lt19(vxw280, vxw260, app(app(app(ty_@3, bcc), bcd), bce)) → new_lt5(vxw280, vxw260, bcc, bcd, bce)
new_ltEs10(vxw281, vxw261, ty_Bool) → new_ltEs16(vxw281, vxw261)
new_esEs9(vxw310, vxw4010, app(app(ty_Either, caa), cab)) → new_esEs5(vxw310, vxw4010, caa, cab)
new_lt10(vxw280, vxw260, app(app(ty_Either, db), dc)) → new_lt16(vxw280, vxw260, db, dc)
new_primEqInt(Neg(Zero), Pos(Succ(vxw40100))) → False
new_primEqInt(Pos(Zero), Neg(Succ(vxw40100))) → False
new_ltEs19(vxw282, vxw262, app(app(ty_@2, bea), beb)) → new_ltEs9(vxw282, vxw262, bea, beb)
new_esEs5(Left(vxw310), Left(vxw4010), app(app(ty_@2, dah), dba), dag) → new_esEs4(vxw310, vxw4010, dah, dba)
new_lt19(vxw280, vxw260, ty_Char) → new_lt18(vxw280, vxw260)
new_primCmpInt(Pos(Zero), Pos(Succ(vxw2500))) → new_primCmpNat0(Zero, Succ(vxw2500))
new_esEs21(vxw280, vxw260, ty_Char) → new_esEs11(vxw280, vxw260)
new_esEs23(vxw311, vxw4011, ty_Bool) → new_esEs19(vxw311, vxw4011)
new_esEs8(vxw311, vxw4011, ty_Integer) → new_esEs13(vxw311, vxw4011)
new_esEs22(vxw312, vxw4012, ty_Bool) → new_esEs19(vxw312, vxw4012)
new_ltEs8(GT, LT) → False
new_esEs7(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), ccb, ccc, ccd) → new_asAs(new_esEs24(vxw310, vxw4010, ccb), new_asAs(new_esEs23(vxw311, vxw4011, ccc), new_esEs22(vxw312, vxw4012, ccd)))
new_compare31(vxw270, vxw250, app(app(ty_Either, be), bf)) → new_compare19(vxw270, vxw250, be, bf)
new_esEs26(vxw280, vxw260, ty_Char) → new_esEs11(vxw280, vxw260)
new_compare10(:%(vxw270, vxw271), :%(vxw250, vxw251), ty_Int) → new_compare6(new_sr(vxw270, vxw251), new_sr(vxw250, vxw271))
new_esEs5(Left(vxw310), Left(vxw4010), app(ty_[], dbb), dag) → new_esEs15(vxw310, vxw4010, dbb)
new_lt12(vxw27, vxw25) → new_esEs10(new_compare11(vxw27, vxw25), LT)
new_esEs26(vxw280, vxw260, ty_Float) → new_esEs16(vxw280, vxw260)
new_primCompAux0(vxw77, LT) → LT
new_ltEs6(Left(vxw280), Left(vxw260), ty_Float, ff) → new_ltEs11(vxw280, vxw260)
new_not(False) → True
new_esEs15(:(vxw310, vxw311), :(vxw4010, vxw4011), cad) → new_asAs(new_esEs20(vxw310, vxw4010, cad), new_esEs15(vxw311, vxw4011, cad))
new_compare24(vxw27, vxw25, True, bfa) → EQ
new_esEs5(Right(vxw310), Right(vxw4010), dcb, ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_esEs8(vxw311, vxw4011, app(ty_Maybe, bgb)) → new_esEs6(vxw311, vxw4011, bgb)
new_primCmpInt(Pos(Succ(vxw2700)), Pos(vxw250)) → new_primCmpNat0(Succ(vxw2700), vxw250)
new_primPlusNat0(Zero, vxw401000) → Succ(vxw401000)
new_compare210(vxw27, vxw25, True, cc, cd) → EQ
new_ltEs10(vxw281, vxw261, ty_@0) → new_ltEs7(vxw281, vxw261)
new_ltEs9(@2(vxw280, vxw281), @2(vxw260, vxw261), dh, cf) → new_pePe(new_lt10(vxw280, vxw260, dh), new_asAs(new_esEs21(vxw280, vxw260, dh), new_ltEs10(vxw281, vxw261, cf)))
new_esEs26(vxw280, vxw260, app(ty_Ratio, cgc)) → new_esEs18(vxw280, vxw260, cgc)
new_ltEs17(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), bcf, bbd, bbe) → new_pePe(new_lt19(vxw280, vxw260, bcf), new_asAs(new_esEs26(vxw280, vxw260, bcf), new_pePe(new_lt20(vxw281, vxw261, bbd), new_asAs(new_esEs25(vxw281, vxw261, bbd), new_ltEs19(vxw282, vxw262, bbe)))))
new_esEs16(Float(vxw310, vxw311), Float(vxw4010, vxw4011)) → new_esEs12(new_sr(vxw310, vxw4010), new_sr(vxw311, vxw4011))
new_ltEs6(Right(vxw280), Right(vxw260), gg, ty_Char) → new_ltEs18(vxw280, vxw260)
new_compare17(vxw27, vxw25, True) → LT
new_lt20(vxw281, vxw261, app(app(ty_Either, bdb), bdc)) → new_lt16(vxw281, vxw261, bdb, bdc)
new_lt20(vxw281, vxw261, app(ty_Maybe, bdd)) → new_lt17(vxw281, vxw261, bdd)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, app(ty_[], dce)) → new_esEs15(vxw310, vxw4010, dce)
new_ltEs10(vxw281, vxw261, app(app(ty_Either, ed), ee)) → new_ltEs6(vxw281, vxw261, ed, ee)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Int, dag) → new_esEs12(vxw310, vxw4010)
new_esEs26(vxw280, vxw260, app(app(ty_Either, bbh), bca)) → new_esEs5(vxw280, vxw260, bbh, bca)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Bool, dag) → new_esEs19(vxw310, vxw4010)
new_esEs8(vxw311, vxw4011, app(app(app(ty_@3, bgd), bge), bgf)) → new_esEs7(vxw311, vxw4011, bgd, bge, bgf)
new_primCmpInt(Pos(Succ(vxw2700)), Neg(vxw250)) → GT
new_esEs22(vxw312, vxw4012, app(app(app(ty_@3, cdb), cdc), cdd)) → new_esEs7(vxw312, vxw4012, cdb, cdc, cdd)
new_esEs22(vxw312, vxw4012, ty_Char) → new_esEs11(vxw312, vxw4012)
new_ltEs18(vxw28, vxw26) → new_fsEs(new_compare8(vxw28, vxw26))
new_esEs26(vxw280, vxw260, ty_@0) → new_esEs17(vxw280, vxw260)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Ordering, dag) → new_esEs10(vxw310, vxw4010)
new_primMulInt(Pos(vxw3100), Pos(vxw40100)) → Pos(new_primMulNat0(vxw3100, vxw40100))
new_esEs21(vxw280, vxw260, app(app(ty_@2, cg), da)) → new_esEs4(vxw280, vxw260, cg, da)
new_esEs9(vxw310, vxw4010, app(ty_Ratio, bhe)) → new_esEs18(vxw310, vxw4010, bhe)
new_compare31(vxw270, vxw250, ty_Char) → new_compare8(vxw270, vxw250)
new_esEs5(Left(vxw310), Left(vxw4010), ty_@0, dag) → new_esEs17(vxw310, vxw4010)
new_esEs20(vxw310, vxw4010, ty_Char) → new_esEs11(vxw310, vxw4010)
new_esEs20(vxw310, vxw4010, ty_Bool) → new_esEs19(vxw310, vxw4010)
new_compare31(vxw270, vxw250, ty_Bool) → new_compare12(vxw270, vxw250)
new_esEs5(Left(vxw310), Right(vxw4010), dcb, dag) → False
new_esEs5(Right(vxw310), Left(vxw4010), dcb, dag) → False
new_primMulInt(Neg(vxw3100), Neg(vxw40100)) → Pos(new_primMulNat0(vxw3100, vxw40100))
new_ltEs5(Just(vxw280), Just(vxw260), ty_Double) → new_ltEs15(vxw280, vxw260)
new_primEqNat0(Zero, Succ(vxw40100)) → False
new_primEqNat0(Succ(vxw3100), Zero) → False
new_ltEs5(Nothing, Nothing, cgf) → True
new_ltEs6(Right(vxw280), Right(vxw260), gg, ty_Float) → new_ltEs11(vxw280, vxw260)
new_compare25(vxw27, vxw25, True, fb, fc) → EQ
new_esEs25(vxw281, vxw261, app(ty_Maybe, bdd)) → new_esEs6(vxw281, vxw261, bdd)
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_esEs22(vxw312, vxw4012, ty_Double) → new_esEs14(vxw312, vxw4012)
new_esEs6(Just(vxw310), Just(vxw4010), app(ty_[], chf)) → new_esEs15(vxw310, vxw4010, chf)
new_lt4(vxw27, vxw25) → new_esEs10(new_compare7(vxw27, vxw25), LT)
new_esEs23(vxw311, vxw4011, app(ty_Ratio, cec)) → new_esEs18(vxw311, vxw4011, cec)
new_lt19(vxw280, vxw260, app(ty_Maybe, bcb)) → new_lt17(vxw280, vxw260, bcb)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Ordering, ff) → new_ltEs8(vxw280, vxw260)
new_esEs25(vxw281, vxw261, ty_Int) → new_esEs12(vxw281, vxw261)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Bool) → new_ltEs16(vxw280, vxw260)
new_compare31(vxw270, vxw250, app(app(ty_@2, bc), bd)) → new_compare30(vxw270, vxw250, bc, bd)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Int) → new_ltEs14(vxw280, vxw260)
new_compare28(vxw27, vxw25, True, bfb, bfc, bfd) → EQ
new_ltEs6(Left(vxw280), Left(vxw260), app(ty_Maybe, gc), ff) → new_ltEs5(vxw280, vxw260, gc)
new_lt10(vxw280, vxw260, app(ty_Ratio, cbg)) → new_lt6(vxw280, vxw260, cbg)
new_lt8(vxw27, vxw25) → new_esEs10(new_compare6(vxw27, vxw25), LT)
new_ltEs10(vxw281, vxw261, ty_Float) → new_ltEs11(vxw281, vxw261)
new_ltEs19(vxw282, vxw262, app(ty_Maybe, bee)) → new_ltEs5(vxw282, vxw262, bee)
new_lt10(vxw280, vxw260, app(app(app(ty_@3, de), df), dg)) → new_lt5(vxw280, vxw260, de, df, dg)
new_compare13(vxw27, vxw25, False, bfa) → GT
new_compare25(vxw27, vxw25, False, fb, fc) → new_compare15(vxw27, vxw25, new_ltEs6(vxw27, vxw25, fb, fc), fb, fc)
new_esEs22(vxw312, vxw4012, app(ty_[], ccg)) → new_esEs15(vxw312, vxw4012, ccg)
new_primCmpInt(Neg(Zero), Neg(Succ(vxw2500))) → new_primCmpNat0(Succ(vxw2500), Zero)
new_lt20(vxw281, vxw261, app(app(ty_@2, bch), bda)) → new_lt15(vxw281, vxw261, bch, bda)
new_primCmpInt(Pos(Zero), Neg(Succ(vxw2500))) → GT
new_ltEs6(Left(vxw280), Left(vxw260), app(ty_Ratio, cgh), ff) → new_ltEs12(vxw280, vxw260, cgh)
new_esEs12(vxw31, vxw401) → new_primEqInt(vxw31, vxw401)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Integer, dag) → new_esEs13(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Int) → new_esEs12(vxw310, vxw4010)
new_compare31(vxw270, vxw250, app(ty_[], bb)) → new_compare(vxw270, vxw250, bb)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, ty_Double) → new_esEs14(vxw310, vxw4010)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, app(app(app(ty_@3, dch), dda), ddb)) → new_esEs7(vxw310, vxw4010, dch, dda, ddb)
new_compare15(vxw27, vxw25, False, fb, fc) → GT
new_ltEs5(Just(vxw280), Just(vxw260), ty_Ordering) → new_ltEs8(vxw280, vxw260)
new_esEs20(vxw310, vxw4010, app(ty_Ratio, cba)) → new_esEs18(vxw310, vxw4010, cba)
new_esEs15([], :(vxw4010, vxw4011), cad) → False
new_esEs15(:(vxw310, vxw311), [], cad) → False
new_compare5(Double(vxw270, vxw271), Double(vxw250, vxw251)) → new_compare6(new_sr(vxw270, vxw250), new_sr(vxw271, vxw251))
new_esEs11(Char(vxw310), Char(vxw4010)) → new_primEqNat0(vxw310, vxw4010)
new_compare16(vxw27, vxw25) → new_compare26(vxw27, vxw25, new_esEs10(vxw27, vxw25))
new_esEs6(Just(vxw310), Just(vxw4010), app(app(ty_Either, dad), dae)) → new_esEs5(vxw310, vxw4010, dad, dae)
new_esEs9(vxw310, vxw4010, ty_Double) → new_esEs14(vxw310, vxw4010)
new_compare32(Float(vxw270, vxw271), Float(vxw250, vxw251)) → new_compare6(new_sr(vxw270, vxw250), new_sr(vxw271, vxw251))
new_esEs9(vxw310, vxw4010, app(app(ty_@2, bha), bhb)) → new_esEs4(vxw310, vxw4010, bha, bhb)
new_ltEs6(Right(vxw280), Right(vxw260), gg, app(app(ty_Either, hc), hd)) → new_ltEs6(vxw280, vxw260, hc, hd)
new_esEs8(vxw311, vxw4011, ty_Bool) → new_esEs19(vxw311, vxw4011)
new_esEs8(vxw311, vxw4011, ty_Char) → new_esEs11(vxw311, vxw4011)
new_esEs24(vxw310, vxw4010, app(app(app(ty_@3, cff), cfg), cfh)) → new_esEs7(vxw310, vxw4010, cff, cfg, cfh)
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCompAux1(vxw270, vxw250, vxw72, ba) → new_primCompAux0(vxw72, new_compare31(vxw270, vxw250, ba))
new_esEs20(vxw310, vxw4010, app(ty_Maybe, cah)) → new_esEs6(vxw310, vxw4010, cah)
new_esEs24(vxw310, vxw4010, ty_Char) → new_esEs11(vxw310, vxw4010)
new_asAs(False, vxw56) → False
new_lt14(vxw27, vxw25) → new_esEs10(new_compare5(vxw27, vxw25), LT)
new_esEs14(Double(vxw310, vxw311), Double(vxw4010, vxw4011)) → new_esEs12(new_sr(vxw310, vxw4010), new_sr(vxw311, vxw4011))
new_primMulInt(Neg(vxw3100), Pos(vxw40100)) → Neg(new_primMulNat0(vxw3100, vxw40100))
new_primMulInt(Pos(vxw3100), Neg(vxw40100)) → Neg(new_primMulNat0(vxw3100, vxw40100))
new_primMulNat0(Succ(vxw31000), Zero) → Zero
new_primMulNat0(Zero, Succ(vxw401000)) → Zero
new_esEs9(vxw310, vxw4010, ty_@0) → new_esEs17(vxw310, vxw4010)
new_esEs21(vxw280, vxw260, app(app(ty_Either, db), dc)) → new_esEs5(vxw280, vxw260, db, dc)
new_esEs26(vxw280, vxw260, ty_Integer) → new_esEs13(vxw280, vxw260)
new_esEs6(Just(vxw310), Just(vxw4010), app(ty_Maybe, chg)) → new_esEs6(vxw310, vxw4010, chg)
new_ltEs6(Left(vxw280), Left(vxw260), app(app(ty_@2, fg), fh), ff) → new_ltEs9(vxw280, vxw260, fg, fh)
new_esEs10(GT, GT) → True
new_esEs25(vxw281, vxw261, ty_Ordering) → new_esEs10(vxw281, vxw261)
new_lt19(vxw280, vxw260, app(app(ty_@2, bbf), bbg)) → new_lt15(vxw280, vxw260, bbf, bbg)
new_ltEs10(vxw281, vxw261, app(ty_Maybe, ef)) → new_ltEs5(vxw281, vxw261, ef)
new_esEs20(vxw310, vxw4010, ty_Float) → new_esEs16(vxw310, vxw4010)
new_compare11(Integer(vxw270), Integer(vxw250)) → new_primCmpInt(vxw270, vxw250)
new_ltEs5(Just(vxw280), Just(vxw260), app(ty_Maybe, bag)) → new_ltEs5(vxw280, vxw260, bag)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), app(app(ty_@2, chd), che)) → new_esEs4(vxw310, vxw4010, chd, che)
new_compare110(vxw27, vxw25, True, bfb, bfc, bfd) → LT
new_esEs23(vxw311, vxw4011, app(ty_Maybe, ceb)) → new_esEs6(vxw311, vxw4011, ceb)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_esEs25(vxw281, vxw261, ty_Integer) → new_esEs13(vxw281, vxw261)
new_esEs20(vxw310, vxw4010, app(ty_[], cag)) → new_esEs15(vxw310, vxw4010, cag)
new_esEs28(vxw310, vxw4010, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_esEs8(vxw311, vxw4011, app(ty_Ratio, bgc)) → new_esEs18(vxw311, vxw4011, bgc)
new_esEs20(vxw310, vxw4010, app(app(ty_@2, cae), caf)) → new_esEs4(vxw310, vxw4010, cae, caf)
new_compare27(vxw27, vxw25, True) → EQ
new_ltEs6(Right(vxw280), Right(vxw260), gg, ty_Int) → new_ltEs14(vxw280, vxw260)
new_ltEs8(LT, GT) → True
new_esEs5(Right(vxw310), Right(vxw4010), dcb, app(ty_Maybe, dcf)) → new_esEs6(vxw310, vxw4010, dcf)
new_esEs26(vxw280, vxw260, app(ty_[], bbc)) → new_esEs15(vxw280, vxw260, bbc)
new_esEs22(vxw312, vxw4012, ty_Float) → new_esEs16(vxw312, vxw4012)
new_esEs25(vxw281, vxw261, app(app(app(ty_@3, bde), bdf), bdg)) → new_esEs7(vxw281, vxw261, bde, bdf, bdg)
new_compare31(vxw270, vxw250, ty_Double) → new_compare5(vxw270, vxw250)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, ty_Int) → new_esEs12(vxw310, vxw4010)
new_lt10(vxw280, vxw260, ty_Double) → new_lt14(vxw280, vxw260)
new_esEs20(vxw310, vxw4010, ty_Int) → new_esEs12(vxw310, vxw4010)
new_ltEs6(Left(vxw280), Left(vxw260), app(ty_[], fd), ff) → new_ltEs4(vxw280, vxw260, fd)
new_lt20(vxw281, vxw261, ty_Integer) → new_lt12(vxw281, vxw261)
new_lt20(vxw281, vxw261, ty_Float) → new_lt11(vxw281, vxw261)
new_ltEs6(Right(vxw280), Right(vxw260), gg, ty_Ordering) → new_ltEs8(vxw280, vxw260)
new_compare26(vxw27, vxw25, False) → new_compare17(vxw27, vxw25, new_ltEs8(vxw27, vxw25))
new_ltEs6(Right(vxw280), Right(vxw260), gg, ty_Double) → new_ltEs15(vxw280, vxw260)
new_lt10(vxw280, vxw260, ty_Int) → new_lt8(vxw280, vxw260)
new_esEs5(Left(vxw310), Left(vxw4010), app(app(ty_Either, dbh), dca), dag) → new_esEs5(vxw310, vxw4010, dbh, dca)
new_ltEs19(vxw282, vxw262, app(app(app(ty_@3, bef), beg), beh)) → new_ltEs17(vxw282, vxw262, bef, beg, beh)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Float) → new_esEs16(vxw310, vxw4010)
new_compare14(vxw27, vxw25, True, cc, cd) → LT
new_esEs10(GT, LT) → False
new_esEs10(LT, GT) → False
new_ltEs19(vxw282, vxw262, ty_Double) → new_ltEs15(vxw282, vxw262)
new_esEs10(EQ, LT) → False
new_esEs10(LT, EQ) → False
new_ltEs6(Right(vxw280), Right(vxw260), gg, app(ty_[], gh)) → new_ltEs4(vxw280, vxw260, gh)
new_lt20(vxw281, vxw261, app(app(app(ty_@3, bde), bdf), bdg)) → new_lt5(vxw281, vxw261, bde, bdf, bdg)
new_ltEs8(LT, LT) → True
new_esEs28(vxw310, vxw4010, ty_Int) → new_esEs12(vxw310, vxw4010)
new_ltEs6(Right(vxw280), Right(vxw260), gg, ty_Bool) → new_ltEs16(vxw280, vxw260)
new_primPlusNat1(Zero, Zero) → Zero
new_asAs(True, vxw56) → vxw56
new_esEs24(vxw310, vxw4010, ty_Float) → new_esEs16(vxw310, vxw4010)
new_esEs5(Right(vxw310), Right(vxw4010), dcb, ty_Char) → new_esEs11(vxw310, vxw4010)
new_ltEs7(vxw28, vxw26) → new_fsEs(new_compare7(vxw28, vxw26))
new_primMulNat0(Succ(vxw31000), Succ(vxw401000)) → new_primPlusNat0(new_primMulNat0(vxw31000, Succ(vxw401000)), vxw401000)
new_ltEs16(False, False) → True
new_lt10(vxw280, vxw260, ty_Ordering) → new_lt9(vxw280, vxw260)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Float, dag) → new_esEs16(vxw310, vxw4010)
new_compare17(vxw27, vxw25, False) → GT
new_esEs22(vxw312, vxw4012, ty_Ordering) → new_esEs10(vxw312, vxw4012)
new_ltEs6(Right(vxw280), Right(vxw260), gg, ty_@0) → new_ltEs7(vxw280, vxw260)
new_lt10(vxw280, vxw260, app(ty_Maybe, dd)) → new_lt17(vxw280, vxw260, dd)
new_compare31(vxw270, vxw250, app(ty_Ratio, chb)) → new_compare10(vxw270, vxw250, chb)
new_ltEs10(vxw281, vxw261, ty_Integer) → new_ltEs13(vxw281, vxw261)
new_ltEs19(vxw282, vxw262, ty_Integer) → new_ltEs13(vxw282, vxw262)
new_ltEs5(Just(vxw280), Just(vxw260), app(ty_[], bab)) → new_ltEs4(vxw280, vxw260, bab)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Bool, ff) → new_ltEs16(vxw280, vxw260)
new_ltEs11(vxw28, vxw26) → new_fsEs(new_compare32(vxw28, vxw26))
new_ltEs13(vxw28, vxw26) → new_fsEs(new_compare11(vxw28, vxw26))
new_lt19(vxw280, vxw260, ty_Double) → new_lt14(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, app(ty_Maybe, cfd)) → new_esEs6(vxw310, vxw4010, cfd)
new_ltEs10(vxw281, vxw261, ty_Ordering) → new_ltEs8(vxw281, vxw261)
new_ltEs10(vxw281, vxw261, ty_Int) → new_ltEs14(vxw281, vxw261)
new_compare110(vxw27, vxw25, False, bfb, bfc, bfd) → GT
new_esEs22(vxw312, vxw4012, app(app(ty_Either, cde), cdf)) → new_esEs5(vxw312, vxw4012, cde, cdf)
new_compare8(Char(vxw270), Char(vxw250)) → new_primCmpNat0(vxw270, vxw250)
new_esEs21(vxw280, vxw260, ty_Float) → new_esEs16(vxw280, vxw260)
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCompAux0(vxw77, EQ) → vxw77
new_ltEs19(vxw282, vxw262, app(app(ty_Either, bec), bed)) → new_ltEs6(vxw282, vxw262, bec, bed)
new_esEs24(vxw310, vxw4010, app(ty_[], cfc)) → new_esEs15(vxw310, vxw4010, cfc)
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_esEs21(vxw280, vxw260, app(ty_Ratio, cbg)) → new_esEs18(vxw280, vxw260, cbg)
new_primCmpInt(Neg(Succ(vxw2700)), Pos(vxw250)) → LT
new_esEs24(vxw310, vxw4010, ty_Double) → new_esEs14(vxw310, vxw4010)
new_not(True) → False
new_esEs6(Just(vxw310), Just(vxw4010), app(ty_Ratio, chh)) → new_esEs18(vxw310, vxw4010, chh)

The set Q consists of the following terms:

new_esEs15([], [], x0)
new_ltEs14(x0, x1)
new_esEs22(x0, x1, ty_Int)
new_primEqNat0(Zero, Succ(x0))
new_lt20(x0, x1, ty_Char)
new_ltEs6(Right(x0), Right(x1), x2, ty_@0)
new_esEs21(x0, x1, ty_Ordering)
new_esEs5(Right(x0), Left(x1), x2, x3)
new_esEs5(Left(x0), Right(x1), x2, x3)
new_ltEs16(True, True)
new_ltEs5(Nothing, Nothing, x0)
new_esEs6(Just(x0), Just(x1), app(ty_Ratio, x2))
new_lt5(x0, x1, x2, x3, x4)
new_esEs23(x0, x1, ty_Int)
new_esEs22(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs6(Just(x0), Just(x1), app(ty_Maybe, x2))
new_ltEs8(EQ, EQ)
new_esEs24(x0, x1, app(ty_Ratio, x2))
new_ltEs19(x0, x1, app(ty_Maybe, x2))
new_esEs26(x0, x1, app(app(ty_Either, x2), x3))
new_compare(:(x0, x1), [], x2)
new_esEs23(x0, x1, app(ty_[], x2))
new_primMulInt(Pos(x0), Pos(x1))
new_esEs20(x0, x1, ty_Char)
new_lt19(x0, x1, ty_Bool)
new_esEs20(x0, x1, app(ty_Maybe, x2))
new_esEs5(Left(x0), Left(x1), ty_@0, x2)
new_esEs6(Just(x0), Just(x1), ty_Bool)
new_esEs22(x0, x1, ty_Bool)
new_ltEs10(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs5(Right(x0), Right(x1), x2, ty_@0)
new_esEs8(x0, x1, ty_Char)
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_esEs15([], :(x0, x1), x2)
new_primPlusNat1(Succ(x0), Zero)
new_ltEs5(Just(x0), Just(x1), ty_Bool)
new_esEs5(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_primPlusNat1(Zero, Succ(x0))
new_esEs10(GT, EQ)
new_esEs10(EQ, GT)
new_ltEs6(Left(x0), Left(x1), ty_Float, x2)
new_esEs5(Right(x0), Right(x1), x2, ty_Int)
new_compare16(x0, x1)
new_compare25(x0, x1, True, x2, x3)
new_esEs10(EQ, LT)
new_esEs10(LT, EQ)
new_esEs6(Just(x0), Just(x1), ty_Float)
new_esEs6(Nothing, Just(x0), x1)
new_lt10(x0, x1, app(ty_Ratio, x2))
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_primMulInt(Neg(x0), Neg(x1))
new_compare28(x0, x1, False, x2, x3, x4)
new_primMulNat0(Succ(x0), Succ(x1))
new_esEs21(x0, x1, app(ty_Ratio, x2))
new_esEs9(x0, x1, app(app(ty_Either, x2), x3))
new_lt11(x0, x1)
new_esEs5(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_esEs9(x0, x1, app(ty_[], x2))
new_esEs22(x0, x1, app(ty_[], x2))
new_esEs5(Right(x0), Right(x1), x2, ty_Ordering)
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_esEs9(x0, x1, ty_Float)
new_ltEs5(Just(x0), Just(x1), ty_Char)
new_esEs8(x0, x1, ty_Bool)
new_ltEs19(x0, x1, ty_Integer)
new_ltEs6(Right(x0), Right(x1), x2, ty_Bool)
new_esEs9(x0, x1, app(ty_Ratio, x2))
new_esEs9(x0, x1, app(ty_Maybe, x2))
new_lt20(x0, x1, ty_Int)
new_esEs6(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_esEs5(Right(x0), Right(x1), x2, ty_Integer)
new_esEs27(x0, x1, ty_Integer)
new_lt10(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs6(Right(x0), Right(x1), x2, ty_Int)
new_ltEs10(x0, x1, ty_Double)
new_ltEs5(Just(x0), Just(x1), ty_Float)
new_lt19(x0, x1, app(ty_Maybe, x2))
new_compare(:(x0, x1), :(x2, x3), x4)
new_esEs19(True, True)
new_lt14(x0, x1)
new_ltEs19(x0, x1, ty_@0)
new_compare31(x0, x1, ty_Bool)
new_compare13(x0, x1, True, x2)
new_ltEs6(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_compare15(x0, x1, False, x2, x3)
new_ltEs10(x0, x1, ty_Bool)
new_esEs25(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs8(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt20(x0, x1, ty_Ordering)
new_ltEs5(Just(x0), Just(x1), app(ty_[], x2))
new_esEs26(x0, x1, ty_Integer)
new_compare24(x0, x1, False, x2)
new_esEs21(x0, x1, app(app(ty_Either, x2), x3))
new_esEs7(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_ltEs10(x0, x1, ty_Ordering)
new_esEs18(:%(x0, x1), :%(x2, x3), x4)
new_primMulNat0(Zero, Succ(x0))
new_esEs25(x0, x1, ty_@0)
new_esEs25(x0, x1, ty_Int)
new_esEs26(x0, x1, ty_Ordering)
new_esEs8(x0, x1, app(ty_[], x2))
new_compare25(x0, x1, False, x2, x3)
new_primEqNat0(Zero, Zero)
new_ltEs6(Right(x0), Right(x1), x2, app(ty_[], x3))
new_lt19(x0, x1, ty_Char)
new_lt19(x0, x1, ty_@0)
new_esEs6(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_lt10(x0, x1, app(ty_Maybe, x2))
new_ltEs10(x0, x1, app(ty_Maybe, x2))
new_ltEs11(x0, x1)
new_pePe(True, x0)
new_lt18(x0, x1)
new_ltEs5(Just(x0), Just(x1), ty_Ordering)
new_pePe(False, x0)
new_esEs26(x0, x1, ty_Float)
new_primMulNat0(Zero, Zero)
new_compare31(x0, x1, ty_Int)
new_ltEs19(x0, x1, ty_Double)
new_esEs22(x0, x1, ty_Float)
new_lt20(x0, x1, app(app(ty_Either, x2), x3))
new_compare31(x0, x1, ty_Char)
new_esEs23(x0, x1, ty_@0)
new_esEs23(x0, x1, app(ty_Ratio, x2))
new_esEs20(x0, x1, ty_Bool)
new_compare31(x0, x1, ty_Integer)
new_esEs6(Just(x0), Just(x1), ty_Integer)
new_esEs20(x0, x1, ty_Int)
new_esEs4(@2(x0, x1), @2(x2, x3), x4, x5)
new_compare210(x0, x1, True, x2, x3)
new_esEs20(x0, x1, app(app(ty_Either, x2), x3))
new_esEs5(Right(x0), Right(x1), x2, ty_Double)
new_ltEs6(Left(x0), Left(x1), ty_Bool, x2)
new_lt19(x0, x1, app(ty_[], x2))
new_esEs26(x0, x1, app(ty_[], x2))
new_lt10(x0, x1, ty_@0)
new_esEs9(x0, x1, ty_@0)
new_primCmpInt(Neg(Succ(x0)), Neg(x1))
new_ltEs5(Just(x0), Just(x1), app(ty_Maybe, x2))
new_esEs5(Left(x0), Left(x1), ty_Double, x2)
new_esEs10(GT, LT)
new_esEs10(LT, GT)
new_esEs22(x0, x1, app(app(ty_@2, x2), x3))
new_primCmpNat0(Succ(x0), Zero)
new_ltEs19(x0, x1, app(ty_Ratio, x2))
new_esEs22(x0, x1, app(app(ty_Either, x2), x3))
new_primCompAux0(x0, GT)
new_esEs28(x0, x1, ty_Int)
new_compare31(x0, x1, app(app(ty_@2, x2), x3))
new_compare30(x0, x1, x2, x3)
new_esEs5(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_esEs26(x0, x1, ty_Char)
new_lt4(x0, x1)
new_asAs(False, x0)
new_compare110(x0, x1, False, x2, x3, x4)
new_esEs15(:(x0, x1), [], x2)
new_ltEs10(x0, x1, ty_Int)
new_esEs9(x0, x1, ty_Double)
new_esEs26(x0, x1, app(ty_Maybe, x2))
new_compare31(x0, x1, app(ty_[], x2))
new_esEs24(x0, x1, app(ty_Maybe, x2))
new_esEs23(x0, x1, app(app(ty_@2, x2), x3))
new_esEs25(x0, x1, app(app(ty_@2, x2), x3))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_esEs6(Just(x0), Just(x1), ty_Int)
new_asAs(True, x0)
new_compare29(x0, x1, x2)
new_esEs22(x0, x1, ty_Double)
new_esEs23(x0, x1, ty_Bool)
new_esEs5(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_compare110(x0, x1, True, x2, x3, x4)
new_esEs21(x0, x1, ty_Int)
new_esEs21(x0, x1, ty_Bool)
new_lt20(x0, x1, app(app(ty_@2, x2), x3))
new_esEs25(x0, x1, ty_Float)
new_esEs23(x0, x1, ty_Integer)
new_esEs19(False, True)
new_esEs19(True, False)
new_esEs25(x0, x1, app(app(ty_Either, x2), x3))
new_compare14(x0, x1, False, x2, x3)
new_esEs26(x0, x1, ty_@0)
new_esEs8(x0, x1, app(ty_Ratio, x2))
new_esEs5(Left(x0), Left(x1), app(ty_[], x2), x3)
new_compare14(x0, x1, True, x2, x3)
new_primPlusNat1(Zero, Zero)
new_esEs26(x0, x1, ty_Bool)
new_esEs5(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_ltEs10(x0, x1, app(ty_Ratio, x2))
new_ltEs6(Right(x0), Right(x1), x2, ty_Integer)
new_ltEs19(x0, x1, ty_Bool)
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_compare18(x0, x1, False)
new_compare31(x0, x1, ty_Double)
new_ltEs10(x0, x1, ty_Char)
new_esEs10(EQ, EQ)
new_lt10(x0, x1, ty_Float)
new_compare9(x0, x1, x2, x3, x4)
new_esEs21(x0, x1, ty_Float)
new_esEs24(x0, x1, app(app(ty_Either, x2), x3))
new_esEs9(x0, x1, ty_Int)
new_esEs23(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primCmpInt(Neg(Zero), Neg(Zero))
new_esEs23(x0, x1, ty_Float)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_lt20(x0, x1, ty_Integer)
new_ltEs10(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs5(Just(x0), Nothing, x1)
new_ltEs18(x0, x1)
new_esEs20(x0, x1, app(app(ty_@2, x2), x3))
new_esEs27(x0, x1, ty_Int)
new_compare28(x0, x1, True, x2, x3, x4)
new_esEs24(x0, x1, ty_Ordering)
new_esEs17(@0, @0)
new_ltEs6(Left(x0), Left(x1), ty_Int, x2)
new_esEs26(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs5(Right(x0), Right(x1), x2, ty_Bool)
new_esEs5(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_esEs21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs20(x0, x1, ty_@0)
new_ltEs5(Just(x0), Just(x1), app(ty_Ratio, x2))
new_esEs9(x0, x1, ty_Bool)
new_ltEs5(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_esEs21(x0, x1, ty_Integer)
new_ltEs5(Just(x0), Just(x1), ty_@0)
new_ltEs10(x0, x1, app(app(ty_Either, x2), x3))
new_lt20(x0, x1, ty_@0)
new_esEs6(Just(x0), Nothing, x1)
new_primCompAux0(x0, LT)
new_ltEs17(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_ltEs6(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_esEs25(x0, x1, ty_Ordering)
new_esEs5(Left(x0), Left(x1), ty_Float, x2)
new_esEs5(Left(x0), Left(x1), ty_Integer, x2)
new_esEs8(x0, x1, ty_@0)
new_compare17(x0, x1, True)
new_esEs5(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_esEs5(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_esEs5(Right(x0), Right(x1), x2, app(ty_[], x3))
new_primEqInt(Neg(Zero), Pos(Zero))
new_primEqInt(Pos(Zero), Neg(Zero))
new_lt8(x0, x1)
new_ltEs19(x0, x1, ty_Float)
new_ltEs19(x0, x1, ty_Int)
new_esEs6(Nothing, Nothing, x0)
new_compare([], :(x0, x1), x2)
new_esEs9(x0, x1, ty_Ordering)
new_esEs20(x0, x1, ty_Double)
new_esEs8(x0, x1, ty_Double)
new_ltEs8(EQ, LT)
new_ltEs8(LT, EQ)
new_compare32(Float(x0, x1), Float(x2, x3))
new_compare17(x0, x1, False)
new_esEs23(x0, x1, ty_Double)
new_esEs8(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs4(x0, x1, x2)
new_esEs19(False, False)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_lt12(x0, x1)
new_lt13(x0, x1, x2)
new_lt10(x0, x1, ty_Bool)
new_compare19(x0, x1, x2, x3)
new_lt19(x0, x1, ty_Float)
new_ltEs19(x0, x1, app(ty_[], x2))
new_ltEs6(Right(x0), Right(x1), x2, ty_Float)
new_primEqInt(Neg(Zero), Neg(Zero))
new_esEs23(x0, x1, app(ty_Maybe, x2))
new_compare15(x0, x1, True, x2, x3)
new_esEs24(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs6(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_ltEs6(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_esEs15(:(x0, x1), :(x2, x3), x4)
new_esEs25(x0, x1, ty_Integer)
new_esEs9(x0, x1, ty_Char)
new_esEs26(x0, x1, app(ty_Ratio, x2))
new_esEs8(x0, x1, ty_Int)
new_primCompAux0(x0, EQ)
new_ltEs6(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_esEs12(x0, x1)
new_compare7(@0, @0)
new_compare31(x0, x1, ty_Float)
new_esEs25(x0, x1, ty_Bool)
new_sr(x0, x1)
new_esEs21(x0, x1, app(ty_[], x2))
new_ltEs6(Left(x0), Left(x1), ty_Char, x2)
new_esEs5(Right(x0), Right(x1), x2, ty_Char)
new_ltEs6(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_esEs10(LT, LT)
new_esEs6(Just(x0), Just(x1), ty_Char)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_esEs22(x0, x1, ty_Integer)
new_ltEs16(True, False)
new_ltEs16(False, True)
new_lt16(x0, x1, x2, x3)
new_primEqNat0(Succ(x0), Zero)
new_esEs26(x0, x1, ty_Double)
new_lt20(x0, x1, ty_Float)
new_ltEs6(Right(x0), Right(x1), x2, ty_Double)
new_esEs6(Just(x0), Just(x1), ty_Ordering)
new_esEs6(Just(x0), Just(x1), app(ty_[], x2))
new_compare10(:%(x0, x1), :%(x2, x3), ty_Integer)
new_fsEs(x0)
new_esEs14(Double(x0, x1), Double(x2, x3))
new_ltEs8(LT, LT)
new_primCmpNat0(Zero, Zero)
new_esEs8(x0, x1, app(app(ty_@2, x2), x3))
new_lt20(x0, x1, app(ty_Maybe, x2))
new_lt19(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs6(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_esEs9(x0, x1, ty_Integer)
new_lt17(x0, x1, x2)
new_ltEs6(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_esEs25(x0, x1, app(ty_Ratio, x2))
new_lt9(x0, x1)
new_ltEs9(@2(x0, x1), @2(x2, x3), x4, x5)
new_ltEs8(GT, GT)
new_ltEs5(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_primCmpInt(Pos(Succ(x0)), Pos(x1))
new_ltEs6(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_lt20(x0, x1, ty_Double)
new_ltEs19(x0, x1, ty_Char)
new_ltEs6(Left(x0), Left(x1), ty_Integer, x2)
new_compare26(x0, x1, False)
new_ltEs19(x0, x1, app(app(ty_Either, x2), x3))
new_esEs20(x0, x1, ty_Ordering)
new_ltEs13(x0, x1)
new_esEs20(x0, x1, ty_Float)
new_ltEs15(x0, x1)
new_ltEs10(x0, x1, ty_Float)
new_ltEs19(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs19(x0, x1, ty_Ordering)
new_esEs9(x0, x1, app(app(ty_@2, x2), x3))
new_lt7(x0, x1)
new_compare27(x0, x1, True)
new_esEs21(x0, x1, ty_Char)
new_esEs22(x0, x1, ty_Ordering)
new_lt10(x0, x1, ty_Char)
new_lt15(x0, x1, x2, x3)
new_primPlusNat0(Succ(x0), x1)
new_esEs26(x0, x1, ty_Int)
new_primPlusNat0(Zero, x0)
new_compare8(Char(x0), Char(x1))
new_esEs24(x0, x1, ty_Bool)
new_ltEs6(Right(x0), Right(x1), x2, ty_Char)
new_lt10(x0, x1, ty_Integer)
new_esEs24(x0, x1, ty_Char)
new_esEs10(GT, GT)
new_esEs25(x0, x1, app(ty_[], x2))
new_ltEs10(x0, x1, ty_Integer)
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_ltEs12(x0, x1, x2)
new_esEs5(Left(x0), Left(x1), ty_Ordering, x2)
new_sr0(Integer(x0), Integer(x1))
new_esEs23(x0, x1, ty_Ordering)
new_compare13(x0, x1, False, x2)
new_esEs13(Integer(x0), Integer(x1))
new_ltEs8(LT, GT)
new_ltEs8(GT, LT)
new_compare26(x0, x1, True)
new_primMulNat0(Succ(x0), Zero)
new_esEs24(x0, x1, ty_@0)
new_ltEs6(Left(x0), Left(x1), app(ty_[], x2), x3)
new_ltEs6(Left(x0), Right(x1), x2, x3)
new_ltEs6(Right(x0), Left(x1), x2, x3)
new_ltEs6(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_ltEs10(x0, x1, ty_@0)
new_esEs28(x0, x1, ty_Integer)
new_esEs6(Just(x0), Just(x1), ty_Double)
new_primCmpNat0(Succ(x0), Succ(x1))
new_lt19(x0, x1, app(ty_Ratio, x2))
new_esEs20(x0, x1, app(ty_Ratio, x2))
new_esEs24(x0, x1, app(ty_[], x2))
new_lt10(x0, x1, ty_Double)
new_lt20(x0, x1, ty_Bool)
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_lt10(x0, x1, app(ty_[], x2))
new_primCompAux1(x0, x1, x2, x3)
new_lt20(x0, x1, app(ty_[], x2))
new_not(True)
new_esEs24(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare10(:%(x0, x1), :%(x2, x3), ty_Int)
new_ltEs10(x0, x1, app(ty_[], x2))
new_esEs21(x0, x1, app(ty_Maybe, x2))
new_esEs26(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs6(Left(x0), Left(x1), ty_Double, x2)
new_esEs5(Left(x0), Left(x1), ty_Bool, x2)
new_compare31(x0, x1, ty_Ordering)
new_esEs16(Float(x0, x1), Float(x2, x3))
new_compare31(x0, x1, ty_@0)
new_compare([], [], x0)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_esEs8(x0, x1, ty_Ordering)
new_not(False)
new_lt10(x0, x1, ty_Ordering)
new_esEs8(x0, x1, ty_Float)
new_esEs22(x0, x1, app(ty_Ratio, x2))
new_ltEs6(Left(x0), Left(x1), ty_@0, x2)
new_esEs22(x0, x1, ty_Char)
new_esEs20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt10(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt19(x0, x1, ty_Integer)
new_primPlusNat1(Succ(x0), Succ(x1))
new_ltEs5(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_esEs5(Right(x0), Right(x1), x2, ty_Float)
new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_esEs9(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs5(Left(x0), Left(x1), ty_Char, x2)
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_ltEs6(Right(x0), Right(x1), x2, ty_Ordering)
new_lt19(x0, x1, app(app(ty_Either, x2), x3))
new_compare11(Integer(x0), Integer(x1))
new_compare6(x0, x1)
new_compare24(x0, x1, True, x2)
new_esEs25(x0, x1, ty_Char)
new_esEs25(x0, x1, app(ty_Maybe, x2))
new_compare12(x0, x1)
new_esEs23(x0, x1, app(app(ty_Either, x2), x3))
new_esEs20(x0, x1, app(ty_[], x2))
new_esEs11(Char(x0), Char(x1))
new_compare5(Double(x0, x1), Double(x2, x3))
new_esEs24(x0, x1, ty_Integer)
new_lt20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare31(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs8(GT, EQ)
new_ltEs8(EQ, GT)
new_ltEs5(Just(x0), Just(x1), ty_Double)
new_esEs5(Left(x0), Left(x1), ty_Int, x2)
new_ltEs5(Just(x0), Just(x1), ty_Int)
new_lt19(x0, x1, ty_Double)
new_esEs24(x0, x1, ty_Int)
new_esEs20(x0, x1, ty_Integer)
new_esEs8(x0, x1, app(ty_Maybe, x2))
new_ltEs6(Left(x0), Left(x1), ty_Ordering, x2)
new_esEs22(x0, x1, ty_@0)
new_esEs6(Just(x0), Just(x1), ty_@0)
new_lt19(x0, x1, ty_Int)
new_lt6(x0, x1, x2)
new_lt19(x0, x1, app(app(ty_@2, x2), x3))
new_esEs22(x0, x1, app(ty_Maybe, x2))
new_ltEs7(x0, x1)
new_compare31(x0, x1, app(app(ty_Either, x2), x3))
new_esEs24(x0, x1, ty_Float)
new_esEs5(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_esEs24(x0, x1, ty_Double)
new_primEqInt(Pos(Zero), Pos(Zero))
new_lt19(x0, x1, ty_Ordering)
new_ltEs5(Nothing, Just(x0), x1)
new_esEs21(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs19(x0, x1, app(app(ty_@2, x2), x3))
new_esEs23(x0, x1, ty_Char)
new_lt20(x0, x1, app(ty_Ratio, x2))
new_ltEs6(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_esEs25(x0, x1, ty_Double)
new_primMulInt(Pos(x0), Neg(x1))
new_primMulInt(Neg(x0), Pos(x1))
new_esEs21(x0, x1, ty_Double)
new_ltEs5(Just(x0), Just(x1), ty_Integer)
new_esEs8(x0, x1, ty_Integer)
new_ltEs16(False, False)
new_compare18(x0, x1, True)
new_esEs5(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_compare31(x0, x1, app(ty_Ratio, x2))
new_lt10(x0, x1, app(app(ty_@2, x2), x3))
new_compare27(x0, x1, False)
new_lt10(x0, x1, ty_Int)
new_esEs21(x0, x1, ty_@0)
new_primCmpNat0(Zero, Succ(x0))
new_compare210(x0, x1, False, x2, x3)
new_compare31(x0, x1, app(ty_Maybe, x2))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ CR
    ↳ HASKELL
      ↳ IFR
        ↳ HASKELL
          ↳ BR
            ↳ HASKELL
              ↳ COR
                ↳ HASKELL
                  ↳ LetRed
                    ↳ HASKELL
                      ↳ NumRed
                        ↳ HASKELL
                          ↳ Narrow
                            ↳ AND
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
                              ↳ QDP
QDP
                                ↳ QDPSizeChangeProof

Q DP problem:
The TRS P consists of the following rules:

new_insertBy00(vxw45, vxw46, vxw47, vxw48, vxw49, False, bc, bd) → new_insertBy(@2(vxw47, vxw48), vxw49, bc, bd)
new_insertBy(@2(vxw30, vxw31), :(@2(vxw400, vxw401), vxw41), be, bf) → new_insertBy0(vxw400, vxw401, vxw30, vxw31, vxw41, new_asAs(new_esEs31(vxw30, vxw400, be), new_esEs30(vxw31, vxw401, bf)), be, bf)
new_insertBy0(vxw25, vxw26, vxw27, vxw28, vxw29, False, ba, bb) → new_insertBy00(vxw25, vxw26, vxw27, vxw28, vxw29, new_pePe(new_lt21(vxw27, vxw25, ba), new_asAs(new_esEs29(vxw27, vxw25, ba), new_ltEs20(vxw28, vxw26, bb))), ba, bb)

The TRS R consists of the following rules:

new_esEs30(vxw31, vxw401, app(ty_Maybe, dbc)) → new_esEs6(vxw31, vxw401, dbc)
new_esEs23(vxw311, vxw4011, ty_Integer) → new_esEs13(vxw311, vxw4011)
new_esEs9(vxw310, vxw4010, ty_Char) → new_esEs11(vxw310, vxw4010)
new_esEs24(vxw310, vxw4010, app(app(ty_Either, cac), cad)) → new_esEs5(vxw310, vxw4010, cac, cad)
new_ltEs20(vxw28, vxw26, ty_Char) → new_ltEs18(vxw28, vxw26)
new_lt5(vxw27, vxw25, ga, gb, gc) → new_esEs10(new_compare9(vxw27, vxw25, ga, gb, gc), LT)
new_compare31(vxw270, vxw250, ty_@0) → new_compare7(vxw270, vxw250)
new_compare31(vxw270, vxw250, ty_Int) → new_compare6(vxw270, vxw250)
new_compare15(vxw27, vxw25, True, bac, bad) → LT
new_esEs29(vxw27, vxw25, ty_Integer) → new_esEs13(vxw27, vxw25)
new_esEs23(vxw311, vxw4011, app(app(ty_Either, bha), bhb)) → new_esEs5(vxw311, vxw4011, bha, bhb)
new_esEs23(vxw311, vxw4011, app(app(ty_@2, bga), bgb)) → new_esEs4(vxw311, vxw4011, bga, bgb)
new_esEs20(vxw310, vxw4010, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_esEs29(vxw27, vxw25, ty_Double) → new_esEs14(vxw27, vxw25)
new_compare([], :(vxw250, vxw251), hh) → LT
new_esEs26(vxw280, vxw260, ty_Double) → new_esEs14(vxw280, vxw260)
new_esEs30(vxw31, vxw401, ty_Integer) → new_esEs13(vxw31, vxw401)
new_ltEs10(vxw281, vxw261, ty_Char) → new_ltEs18(vxw281, vxw261)
new_ltEs15(vxw28, vxw26) → new_fsEs(new_compare5(vxw28, vxw26))
new_ltEs19(vxw282, vxw262, ty_Float) → new_ltEs11(vxw282, vxw262)
new_esEs9(vxw310, vxw4010, ty_Bool) → new_esEs19(vxw310, vxw4010)
new_ltEs5(Just(vxw280), Just(vxw260), app(app(app(ty_@3, cfb), cfc), cfd)) → new_ltEs17(vxw280, vxw260, cfb, cfc, cfd)
new_esEs30(vxw31, vxw401, ty_Char) → new_esEs11(vxw31, vxw401)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Char) → new_ltEs18(vxw280, vxw260)
new_compare31(vxw270, vxw250, ty_Ordering) → new_compare16(vxw270, vxw250)
new_compare31(vxw270, vxw250, app(app(app(ty_@3, dah), dba), dbb)) → new_compare9(vxw270, vxw250, dah, dba, dbb)
new_compare19(vxw27, vxw25, bac, bad) → new_compare25(vxw27, vxw25, new_esEs5(vxw27, vxw25, bac, bad), bac, bad)
new_esEs31(vxw30, vxw400, ty_@0) → new_esEs17(vxw30, vxw400)
new_esEs23(vxw311, vxw4011, ty_Float) → new_esEs16(vxw311, vxw4011)
new_ltEs19(vxw282, vxw262, app(ty_Ratio, cda)) → new_ltEs12(vxw282, vxw262, cda)
new_lt16(vxw27, vxw25, bac, bad) → new_esEs10(new_compare19(vxw27, vxw25, bac, bad), LT)
new_esEs21(vxw280, vxw260, ty_@0) → new_esEs17(vxw280, vxw260)
new_esEs21(vxw280, vxw260, ty_Int) → new_esEs12(vxw280, vxw260)
new_primMulNat0(Zero, Zero) → Zero
new_esEs24(vxw310, vxw4010, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_compare(:(vxw270, vxw271), [], hh) → GT
new_esEs29(vxw27, vxw25, ty_Float) → new_esEs16(vxw27, vxw25)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, ty_Float) → new_esEs16(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Bool) → new_esEs19(vxw310, vxw4010)
new_esEs25(vxw281, vxw261, app(app(ty_@2, cca), ccb)) → new_esEs4(vxw281, vxw261, cca, ccb)
new_compare24(vxw27, vxw25, False, gf) → new_compare13(vxw27, vxw25, new_ltEs5(vxw27, vxw25, gf), gf)
new_ltEs16(False, True) → True
new_esEs18(:%(vxw310, vxw311), :%(vxw4010, vxw4011), dcf) → new_asAs(new_esEs28(vxw310, vxw4010, dcf), new_esEs27(vxw311, vxw4011, dcf))
new_compare12(vxw27, vxw25) → new_compare27(vxw27, vxw25, new_esEs19(vxw27, vxw25))
new_esEs21(vxw280, vxw260, app(ty_[], bca)) → new_esEs15(vxw280, vxw260, bca)
new_esEs22(vxw312, vxw4012, ty_@0) → new_esEs17(vxw312, vxw4012)
new_esEs25(vxw281, vxw261, app(ty_Ratio, cbg)) → new_esEs18(vxw281, vxw261, cbg)
new_esEs21(vxw280, vxw260, ty_Integer) → new_esEs13(vxw280, vxw260)
new_lt9(vxw27, vxw25) → new_esEs10(new_compare16(vxw27, vxw25), LT)
new_compare10(:%(vxw270, vxw271), :%(vxw250, vxw251), ty_Integer) → new_compare11(new_sr0(vxw270, vxw251), new_sr0(vxw250, vxw271))
new_ltEs16(True, False) → False
new_ltEs10(vxw281, vxw261, app(ty_[], bdc)) → new_ltEs4(vxw281, vxw261, bdc)
new_lt10(vxw280, vxw260, ty_Integer) → new_lt12(vxw280, vxw260)
new_lt10(vxw280, vxw260, ty_@0) → new_lt4(vxw280, vxw260)
new_esEs26(vxw280, vxw260, ty_Ordering) → new_esEs10(vxw280, vxw260)
new_ltEs19(vxw282, vxw262, ty_Bool) → new_ltEs16(vxw282, vxw262)
new_lt20(vxw281, vxw261, ty_Double) → new_lt14(vxw281, vxw261)
new_lt19(vxw280, vxw260, app(ty_Ratio, cae)) → new_lt6(vxw280, vxw260, cae)
new_ltEs19(vxw282, vxw262, ty_@0) → new_ltEs7(vxw282, vxw262)
new_ltEs6(Left(vxw280), Left(vxw260), app(app(ty_Either, cga), cgb), hc) → new_ltEs6(vxw280, vxw260, cga, cgb)
new_ltEs5(Just(vxw280), Just(vxw260), ty_@0) → new_ltEs7(vxw280, vxw260)
new_esEs22(vxw312, vxw4012, app(ty_Maybe, bfb)) → new_esEs6(vxw312, vxw4012, bfb)
new_esEs21(vxw280, vxw260, app(app(app(ty_@3, bcg), bch), bda)) → new_esEs7(vxw280, vxw260, bcg, bch, bda)
new_ltEs10(vxw281, vxw261, app(app(app(ty_@3, bea), beb), bec)) → new_ltEs17(vxw281, vxw261, bea, beb, bec)
new_esEs29(vxw27, vxw25, ty_Char) → new_esEs11(vxw27, vxw25)
new_ltEs8(EQ, EQ) → True
new_esEs23(vxw311, vxw4011, ty_Ordering) → new_esEs10(vxw311, vxw4011)
new_esEs27(vxw311, vxw4011, ty_Integer) → new_esEs13(vxw311, vxw4011)
new_esEs8(vxw311, vxw4011, ty_Ordering) → new_esEs10(vxw311, vxw4011)
new_esEs9(vxw310, vxw4010, app(ty_[], eh)) → new_esEs15(vxw310, vxw4010, eh)
new_esEs25(vxw281, vxw261, ty_Double) → new_esEs14(vxw281, vxw261)
new_esEs29(vxw27, vxw25, app(app(app(ty_@3, ga), gb), gc)) → new_esEs7(vxw27, vxw25, ga, gb, gc)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Float) → new_ltEs11(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, ty_@0) → new_esEs17(vxw310, vxw4010)
new_esEs9(vxw310, vxw4010, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Char, dch) → new_esEs11(vxw310, vxw4010)
new_esEs8(vxw311, vxw4011, app(ty_[], df)) → new_esEs15(vxw311, vxw4011, df)
new_lt20(vxw281, vxw261, app(ty_[], cbh)) → new_lt13(vxw281, vxw261, cbh)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, ty_@0) → new_esEs17(vxw310, vxw4010)
new_lt7(vxw27, vxw25) → new_esEs10(new_compare12(vxw27, vxw25), LT)
new_esEs8(vxw311, vxw4011, app(app(ty_@2, dd), de)) → new_esEs4(vxw311, vxw4011, dd, de)
new_esEs22(vxw312, vxw4012, app(ty_Ratio, bfc)) → new_esEs18(vxw312, vxw4012, bfc)
new_compare30(vxw27, vxw25, baa, bab) → new_compare210(vxw27, vxw25, new_esEs4(vxw27, vxw25, baa, bab), baa, bab)
new_ltEs16(True, True) → True
new_ltEs19(vxw282, vxw262, ty_Char) → new_ltEs18(vxw282, vxw262)
new_esEs17(@0, @0) → True
new_ltEs6(Left(vxw280), Left(vxw260), ty_Double, hc) → new_ltEs15(vxw280, vxw260)
new_esEs5(Left(vxw310), Left(vxw4010), app(ty_Maybe, ddd), dch) → new_esEs6(vxw310, vxw4010, ddd)
new_pePe(False, vxw63) → vxw63
new_lt10(vxw280, vxw260, app(ty_[], bca)) → new_lt13(vxw280, vxw260, bca)
new_esEs25(vxw281, vxw261, ty_Char) → new_esEs11(vxw281, vxw261)
new_lt6(vxw27, vxw25, ge) → new_esEs10(new_compare10(vxw27, vxw25, ge), LT)
new_compare31(vxw270, vxw250, ty_Float) → new_compare32(vxw270, vxw250)
new_ltEs6(Right(vxw280), Right(vxw260), hb, app(ty_Maybe, che)) → new_ltEs5(vxw280, vxw260, che)
new_lt19(vxw280, vxw260, ty_Ordering) → new_lt9(vxw280, vxw260)
new_esEs8(vxw311, vxw4011, ty_Float) → new_esEs16(vxw311, vxw4011)
new_esEs29(vxw27, vxw25, ty_@0) → new_esEs17(vxw27, vxw25)
new_esEs8(vxw311, vxw4011, ty_@0) → new_esEs17(vxw311, vxw4011)
new_lt21(vxw27, vxw25, app(app(app(ty_@3, ga), gb), gc)) → new_lt5(vxw27, vxw25, ga, gb, gc)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Int, hc) → new_ltEs14(vxw280, vxw260)
new_esEs22(vxw312, vxw4012, app(app(ty_@2, beg), beh)) → new_esEs4(vxw312, vxw4012, beg, beh)
new_ltEs4(vxw28, vxw26, gd) → new_fsEs(new_compare(vxw28, vxw26, gd))
new_ltEs20(vxw28, vxw26, ty_Ordering) → new_ltEs8(vxw28, vxw26)
new_lt10(vxw280, vxw260, ty_Char) → new_lt18(vxw280, vxw260)
new_esEs20(vxw310, vxw4010, ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_ltEs8(EQ, GT) → True
new_ltEs8(GT, GT) → True
new_ltEs6(Right(vxw280), Right(vxw260), hb, ty_Integer) → new_ltEs13(vxw280, vxw260)
new_compare9(vxw27, vxw25, ga, gb, gc) → new_compare28(vxw27, vxw25, new_esEs7(vxw27, vxw25, ga, gb, gc), ga, gb, gc)
new_esEs31(vxw30, vxw400, ty_Integer) → new_esEs13(vxw30, vxw400)
new_esEs29(vxw27, vxw25, app(app(ty_@2, baa), bab)) → new_esEs4(vxw27, vxw25, baa, bab)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, app(app(ty_@2, dec), ded)) → new_esEs4(vxw310, vxw4010, dec, ded)
new_lt21(vxw27, vxw25, ty_@0) → new_lt4(vxw27, vxw25)
new_esEs23(vxw311, vxw4011, app(app(app(ty_@3, bgf), bgg), bgh)) → new_esEs7(vxw311, vxw4011, bgf, bgg, bgh)
new_esEs23(vxw311, vxw4011, ty_Double) → new_esEs14(vxw311, vxw4011)
new_primCmpNat0(Zero, Succ(vxw2500)) → LT
new_ltEs5(Just(vxw280), Just(vxw260), app(ty_Ratio, cec)) → new_ltEs12(vxw280, vxw260, cec)
new_esEs31(vxw30, vxw400, app(app(ty_@2, bg), bh)) → new_esEs4(vxw30, vxw400, bg, bh)
new_esEs25(vxw281, vxw261, app(app(ty_Either, ccc), ccd)) → new_esEs5(vxw281, vxw261, ccc, ccd)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Char, hc) → new_ltEs18(vxw280, vxw260)
new_ltEs5(Just(vxw280), Just(vxw260), app(app(ty_Either, ceg), ceh)) → new_ltEs6(vxw280, vxw260, ceg, ceh)
new_ltEs10(vxw281, vxw261, ty_Double) → new_ltEs15(vxw281, vxw261)
new_ltEs8(LT, EQ) → True
new_esEs24(vxw310, vxw4010, ty_Int) → new_esEs12(vxw310, vxw4010)
new_esEs10(LT, LT) → True
new_esEs10(GT, EQ) → False
new_esEs10(EQ, GT) → False
new_lt10(vxw280, vxw260, app(app(ty_@2, bcb), bcc)) → new_lt15(vxw280, vxw260, bcb, bcc)
new_pePe(True, vxw63) → True
new_primEqNat0(Zero, Zero) → True
new_compare14(vxw27, vxw25, False, baa, bab) → GT
new_esEs6(Just(vxw310), Just(vxw4010), app(app(app(ty_@3, dca), dcb), dcc)) → new_esEs7(vxw310, vxw4010, dca, dcb, dcc)
new_compare26(vxw27, vxw25, True) → EQ
new_lt10(vxw280, vxw260, ty_Float) → new_lt11(vxw280, vxw260)
new_esEs29(vxw27, vxw25, app(ty_Maybe, gf)) → new_esEs6(vxw27, vxw25, gf)
new_esEs26(vxw280, vxw260, app(ty_Maybe, cbc)) → new_esEs6(vxw280, vxw260, cbc)
new_lt21(vxw27, vxw25, app(app(ty_Either, bac), bad)) → new_lt16(vxw27, vxw25, bac, bad)
new_compare28(vxw27, vxw25, False, ga, gb, gc) → new_compare110(vxw27, vxw25, new_ltEs17(vxw27, vxw25, ga, gb, gc), ga, gb, gc)
new_ltEs20(vxw28, vxw26, ty_@0) → new_ltEs7(vxw28, vxw26)
new_ltEs19(vxw282, vxw262, app(ty_[], cdb)) → new_ltEs4(vxw282, vxw262, cdb)
new_esEs9(vxw310, vxw4010, app(ty_Maybe, fa)) → new_esEs6(vxw310, vxw4010, fa)
new_lt20(vxw281, vxw261, ty_Bool) → new_lt7(vxw281, vxw261)
new_esEs19(True, True) → True
new_esEs6(Just(vxw310), Just(vxw4010), ty_Double) → new_esEs14(vxw310, vxw4010)
new_esEs9(vxw310, vxw4010, ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_lt21(vxw27, vxw25, ty_Bool) → new_lt7(vxw27, vxw25)
new_ltEs8(GT, EQ) → False
new_ltEs8(EQ, LT) → False
new_compare(:(vxw270, vxw271), :(vxw250, vxw251), hh) → new_primCompAux1(vxw270, vxw250, new_compare(vxw271, vxw251, hh), hh)
new_ltEs20(vxw28, vxw26, app(app(ty_@2, gh), ha)) → new_ltEs9(vxw28, vxw26, gh, ha)
new_sr(vxw310, vxw4010) → new_primMulInt(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), ty_@0) → new_esEs17(vxw310, vxw4010)
new_esEs25(vxw281, vxw261, app(ty_[], cbh)) → new_esEs15(vxw281, vxw261, cbh)
new_lt19(vxw280, vxw260, ty_Int) → new_lt8(vxw280, vxw260)
new_esEs23(vxw311, vxw4011, app(ty_[], bgc)) → new_esEs15(vxw311, vxw4011, bgc)
new_esEs9(vxw310, vxw4010, app(app(app(ty_@3, fc), fd), ff)) → new_esEs7(vxw310, vxw4010, fc, fd, ff)
new_esEs26(vxw280, vxw260, ty_Int) → new_esEs12(vxw280, vxw260)
new_esEs31(vxw30, vxw400, app(app(app(ty_@3, cd), ce), cf)) → new_esEs7(vxw30, vxw400, cd, ce, cf)
new_lt11(vxw27, vxw25) → new_esEs10(new_compare32(vxw27, vxw25), LT)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, app(ty_Ratio, deg)) → new_esEs18(vxw310, vxw4010, deg)
new_esEs31(vxw30, vxw400, app(ty_[], ca)) → new_esEs15(vxw30, vxw400, ca)
new_primPlusNat0(Succ(vxw840), vxw401000) → Succ(Succ(new_primPlusNat1(vxw840, vxw401000)))
new_lt17(vxw27, vxw25, gf) → new_esEs10(new_compare29(vxw27, vxw25, gf), LT)
new_esEs25(vxw281, vxw261, ty_Float) → new_esEs16(vxw281, vxw261)
new_lt19(vxw280, vxw260, ty_@0) → new_lt4(vxw280, vxw260)
new_ltEs20(vxw28, vxw26, app(app(ty_Either, hb), hc)) → new_ltEs6(vxw28, vxw26, hb, hc)
new_compare31(vxw270, vxw250, app(ty_Maybe, dag)) → new_compare29(vxw270, vxw250, dag)
new_esEs20(vxw310, vxw4010, app(app(app(ty_@3, bbc), bbd), bbe)) → new_esEs7(vxw310, vxw4010, bbc, bbd, bbe)
new_esEs23(vxw311, vxw4011, ty_Int) → new_esEs12(vxw311, vxw4011)
new_ltEs20(vxw28, vxw26, ty_Bool) → new_ltEs16(vxw28, vxw26)
new_esEs13(Integer(vxw310), Integer(vxw4010)) → new_primEqInt(vxw310, vxw4010)
new_ltEs20(vxw28, vxw26, ty_Int) → new_ltEs14(vxw28, vxw26)
new_ltEs6(Left(vxw280), Left(vxw260), app(app(app(ty_@3, cgd), cge), cgf), hc) → new_ltEs17(vxw280, vxw260, cgd, cge, cgf)
new_esEs29(vxw27, vxw25, ty_Int) → new_esEs12(vxw27, vxw25)
new_lt20(vxw281, vxw261, ty_Ordering) → new_lt9(vxw281, vxw261)
new_esEs10(EQ, EQ) → True
new_primEqInt(Neg(Succ(vxw3100)), Neg(Succ(vxw40100))) → new_primEqNat0(vxw3100, vxw40100)
new_lt15(vxw27, vxw25, baa, bab) → new_esEs10(new_compare30(vxw27, vxw25, baa, bab), LT)
new_ltEs14(vxw28, vxw26) → new_fsEs(new_compare6(vxw28, vxw26))
new_ltEs19(vxw282, vxw262, ty_Ordering) → new_ltEs8(vxw282, vxw262)
new_ltEs5(Just(vxw280), Nothing, hd) → False
new_esEs21(vxw280, vxw260, ty_Ordering) → new_esEs10(vxw280, vxw260)
new_primPlusNat1(Succ(vxw8400), Zero) → Succ(vxw8400)
new_primPlusNat1(Zero, Succ(vxw4010000)) → Succ(vxw4010000)
new_lt19(vxw280, vxw260, ty_Bool) → new_lt7(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, ty_Bool) → new_esEs19(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Integer) → new_esEs13(vxw310, vxw4010)
new_ltEs6(Right(vxw280), Right(vxw260), hb, app(app(ty_@2, cha), chb)) → new_ltEs9(vxw280, vxw260, cha, chb)
new_esEs29(vxw27, vxw25, app(app(ty_Either, bac), bad)) → new_esEs5(vxw27, vxw25, bac, bad)
new_esEs26(vxw280, vxw260, app(app(app(ty_@3, cbd), cbe), cbf)) → new_esEs7(vxw280, vxw260, cbd, cbe, cbf)
new_compare27(vxw27, vxw25, False) → new_compare18(vxw27, vxw25, new_ltEs16(vxw27, vxw25))
new_ltEs10(vxw281, vxw261, app(ty_Ratio, bdb)) → new_ltEs12(vxw281, vxw261, bdb)
new_compare29(vxw27, vxw25, gf) → new_compare24(vxw27, vxw25, new_esEs6(vxw27, vxw25, gf), gf)
new_lt10(vxw280, vxw260, ty_Bool) → new_lt7(vxw280, vxw260)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Integer, hc) → new_ltEs13(vxw280, vxw260)
new_esEs21(vxw280, vxw260, ty_Double) → new_esEs14(vxw280, vxw260)
new_primEqInt(Neg(Zero), Neg(Zero)) → True
new_esEs5(Left(vxw310), Left(vxw4010), app(app(app(ty_@3, ddf), ddg), ddh), dch) → new_esEs7(vxw310, vxw4010, ddf, ddg, ddh)
new_esEs19(False, False) → True
new_esEs27(vxw311, vxw4011, ty_Int) → new_esEs12(vxw311, vxw4011)
new_esEs23(vxw311, vxw4011, ty_Char) → new_esEs11(vxw311, vxw4011)
new_compare31(vxw270, vxw250, ty_Integer) → new_compare11(vxw270, vxw250)
new_ltEs6(Right(vxw280), Right(vxw260), hb, app(ty_Ratio, cgg)) → new_ltEs12(vxw280, vxw260, cgg)
new_lt19(vxw280, vxw260, ty_Integer) → new_lt12(vxw280, vxw260)
new_compare18(vxw27, vxw25, False) → GT
new_esEs9(vxw310, vxw4010, ty_Int) → new_esEs12(vxw310, vxw4010)
new_esEs30(vxw31, vxw401, app(app(app(ty_@3, bed), bee), bef)) → new_esEs7(vxw31, vxw401, bed, bee, bef)
new_ltEs20(vxw28, vxw26, app(ty_[], gd)) → new_ltEs4(vxw28, vxw26, gd)
new_primEqInt(Neg(Succ(vxw3100)), Neg(Zero)) → False
new_primEqInt(Neg(Zero), Neg(Succ(vxw40100))) → False
new_primCompAux0(vxw77, GT) → GT
new_esEs31(vxw30, vxw400, ty_Float) → new_esEs16(vxw30, vxw400)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Double, dch) → new_esEs14(vxw310, vxw4010)
new_esEs31(vxw30, vxw400, app(ty_Ratio, cc)) → new_esEs18(vxw30, vxw400, cc)
new_ltEs19(vxw282, vxw262, ty_Int) → new_ltEs14(vxw282, vxw262)
new_esEs4(@2(vxw310, vxw311), @2(vxw4010, vxw4011), db, dc) → new_asAs(new_esEs9(vxw310, vxw4010, db), new_esEs8(vxw311, vxw4011, dc))
new_esEs31(vxw30, vxw400, app(app(ty_Either, cg), da)) → new_esEs5(vxw30, vxw400, cg, da)
new_ltEs12(vxw28, vxw26, gg) → new_fsEs(new_compare10(vxw28, vxw26, gg))
new_esEs20(vxw310, vxw4010, ty_@0) → new_esEs17(vxw310, vxw4010)
new_esEs22(vxw312, vxw4012, ty_Int) → new_esEs12(vxw312, vxw4012)
new_compare([], [], hh) → EQ
new_lt19(vxw280, vxw260, ty_Float) → new_lt11(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_primCmpInt(Neg(Zero), Pos(Zero)) → EQ
new_primCmpInt(Pos(Zero), Neg(Zero)) → EQ
new_lt20(vxw281, vxw261, ty_Int) → new_lt8(vxw281, vxw261)
new_esEs8(vxw311, vxw4011, ty_Int) → new_esEs12(vxw311, vxw4011)
new_ltEs20(vxw28, vxw26, ty_Double) → new_ltEs15(vxw28, vxw26)
new_compare6(vxw27, vxw25) → new_primCmpInt(vxw27, vxw25)
new_esEs25(vxw281, vxw261, ty_@0) → new_esEs17(vxw281, vxw261)
new_primCmpNat0(Succ(vxw2700), Succ(vxw2500)) → new_primCmpNat0(vxw2700, vxw2500)
new_lt19(vxw280, vxw260, app(app(ty_Either, cba), cbb)) → new_lt16(vxw280, vxw260, cba, cbb)
new_esEs6(Nothing, Nothing, dbc) → True
new_esEs30(vxw31, vxw401, ty_@0) → new_esEs17(vxw31, vxw401)
new_primEqInt(Pos(Succ(vxw3100)), Pos(Succ(vxw40100))) → new_primEqNat0(vxw3100, vxw40100)
new_compare210(vxw27, vxw25, False, baa, bab) → new_compare14(vxw27, vxw25, new_ltEs9(vxw27, vxw25, baa, bab), baa, bab)
new_lt18(vxw27, vxw25) → new_esEs10(new_compare8(vxw27, vxw25), LT)
new_esEs21(vxw280, vxw260, app(ty_Maybe, bcf)) → new_esEs6(vxw280, vxw260, bcf)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Integer) → new_ltEs13(vxw280, vxw260)
new_esEs26(vxw280, vxw260, ty_Bool) → new_esEs19(vxw280, vxw260)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, app(app(ty_Either, dfc), dfd)) → new_esEs5(vxw310, vxw4010, dfc, dfd)
new_esEs6(Nothing, Just(vxw4010), dbc) → False
new_esEs6(Just(vxw310), Nothing, dbc) → False
new_primEqNat0(Succ(vxw3100), Succ(vxw40100)) → new_primEqNat0(vxw3100, vxw40100)
new_compare7(@0, @0) → EQ
new_esEs24(vxw310, vxw4010, app(ty_Ratio, bhg)) → new_esEs18(vxw310, vxw4010, bhg)
new_lt21(vxw27, vxw25, ty_Int) → new_lt8(vxw27, vxw25)
new_esEs9(vxw310, vxw4010, ty_Float) → new_esEs16(vxw310, vxw4010)
new_ltEs5(Just(vxw280), Just(vxw260), app(app(ty_@2, cee), cef)) → new_ltEs9(vxw280, vxw260, cee, cef)
new_esEs20(vxw310, vxw4010, ty_Double) → new_esEs14(vxw310, vxw4010)
new_esEs30(vxw31, vxw401, app(ty_Ratio, dcf)) → new_esEs18(vxw31, vxw401, dcf)
new_esEs8(vxw311, vxw4011, ty_Double) → new_esEs14(vxw311, vxw4011)
new_lt19(vxw280, vxw260, app(ty_[], caf)) → new_lt13(vxw280, vxw260, caf)
new_lt20(vxw281, vxw261, ty_@0) → new_lt4(vxw281, vxw261)
new_primCmpInt(Neg(Succ(vxw2700)), Neg(vxw250)) → new_primCmpNat0(vxw250, Succ(vxw2700))
new_esEs26(vxw280, vxw260, app(app(ty_@2, cag), cah)) → new_esEs4(vxw280, vxw260, cag, cah)
new_ltEs6(Left(vxw280), Right(vxw260), hb, hc) → True
new_ltEs6(Right(vxw280), Left(vxw260), hb, hc) → False
new_esEs15([], [], bae) → True
new_primEqInt(Pos(Succ(vxw3100)), Pos(Zero)) → False
new_primEqInt(Pos(Zero), Pos(Succ(vxw40100))) → False
new_ltEs5(Nothing, Just(vxw260), hd) → True
new_ltEs10(vxw281, vxw261, app(app(ty_@2, bdd), bde)) → new_ltEs9(vxw281, vxw261, bdd, bde)
new_esEs22(vxw312, vxw4012, ty_Integer) → new_esEs13(vxw312, vxw4012)
new_lt13(vxw27, vxw25, hh) → new_esEs10(new_compare(vxw27, vxw25, hh), LT)
new_lt20(vxw281, vxw261, ty_Char) → new_lt18(vxw281, vxw261)
new_compare13(vxw27, vxw25, True, gf) → LT
new_ltEs6(Right(vxw280), Right(vxw260), hb, app(app(app(ty_@3, chf), chg), chh)) → new_ltEs17(vxw280, vxw260, chf, chg, chh)
new_ltEs20(vxw28, vxw26, ty_Integer) → new_ltEs13(vxw28, vxw26)
new_esEs30(vxw31, vxw401, ty_Float) → new_esEs16(vxw31, vxw401)
new_esEs23(vxw311, vxw4011, ty_@0) → new_esEs17(vxw311, vxw4011)
new_esEs21(vxw280, vxw260, ty_Bool) → new_esEs19(vxw280, vxw260)
new_primCmpNat0(Zero, Zero) → EQ
new_primCmpNat0(Succ(vxw2700), Zero) → GT
new_ltEs6(Left(vxw280), Left(vxw260), ty_@0, hc) → new_ltEs7(vxw280, vxw260)
new_compare18(vxw27, vxw25, True) → LT
new_lt20(vxw281, vxw261, app(ty_Ratio, cbg)) → new_lt6(vxw281, vxw261, cbg)
new_primCmpInt(Neg(Zero), Pos(Succ(vxw2500))) → LT
new_esEs19(False, True) → False
new_esEs19(True, False) → False
new_esEs20(vxw310, vxw4010, app(app(ty_Either, bbf), bbg)) → new_esEs5(vxw310, vxw4010, bbf, bbg)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, ty_Bool) → new_esEs19(vxw310, vxw4010)
new_sr0(Integer(vxw2700), Integer(vxw2510)) → Integer(new_primMulInt(vxw2700, vxw2510))
new_primPlusNat1(Succ(vxw8400), Succ(vxw4010000)) → Succ(Succ(new_primPlusNat1(vxw8400, vxw4010000)))
new_esEs29(vxw27, vxw25, app(ty_Ratio, ge)) → new_esEs18(vxw27, vxw25, ge)
new_primEqInt(Pos(Succ(vxw3100)), Neg(vxw4010)) → False
new_primEqInt(Neg(Succ(vxw3100)), Pos(vxw4010)) → False
new_esEs5(Left(vxw310), Left(vxw4010), app(ty_Ratio, dde), dch) → new_esEs18(vxw310, vxw4010, dde)
new_esEs25(vxw281, vxw261, ty_Bool) → new_esEs19(vxw281, vxw261)
new_esEs24(vxw310, vxw4010, app(app(ty_@2, bhc), bhd)) → new_esEs4(vxw310, vxw4010, bhc, bhd)
new_esEs8(vxw311, vxw4011, app(app(ty_Either, ed), ee)) → new_esEs5(vxw311, vxw4011, ed, ee)
new_fsEs(vxw64) → new_not(new_esEs10(vxw64, GT))
new_esEs6(Just(vxw310), Just(vxw4010), ty_Char) → new_esEs11(vxw310, vxw4010)
new_lt19(vxw280, vxw260, app(app(app(ty_@3, cbd), cbe), cbf)) → new_lt5(vxw280, vxw260, cbd, cbe, cbf)
new_ltEs10(vxw281, vxw261, ty_Bool) → new_ltEs16(vxw281, vxw261)
new_esEs9(vxw310, vxw4010, app(app(ty_Either, fg), fh)) → new_esEs5(vxw310, vxw4010, fg, fh)
new_lt21(vxw27, vxw25, ty_Char) → new_lt18(vxw27, vxw25)
new_lt10(vxw280, vxw260, app(app(ty_Either, bcd), bce)) → new_lt16(vxw280, vxw260, bcd, bce)
new_primEqInt(Pos(Zero), Neg(Succ(vxw40100))) → False
new_primEqInt(Neg(Zero), Pos(Succ(vxw40100))) → False
new_ltEs19(vxw282, vxw262, app(app(ty_@2, cdc), cdd)) → new_ltEs9(vxw282, vxw262, cdc, cdd)
new_esEs5(Left(vxw310), Left(vxw4010), app(app(ty_@2, dda), ddb), dch) → new_esEs4(vxw310, vxw4010, dda, ddb)
new_lt19(vxw280, vxw260, ty_Char) → new_lt18(vxw280, vxw260)
new_esEs21(vxw280, vxw260, ty_Char) → new_esEs11(vxw280, vxw260)
new_primCmpInt(Pos(Zero), Pos(Succ(vxw2500))) → new_primCmpNat0(Zero, Succ(vxw2500))
new_esEs31(vxw30, vxw400, ty_Bool) → new_esEs19(vxw30, vxw400)
new_esEs23(vxw311, vxw4011, ty_Bool) → new_esEs19(vxw311, vxw4011)
new_esEs8(vxw311, vxw4011, ty_Integer) → new_esEs13(vxw311, vxw4011)
new_esEs22(vxw312, vxw4012, ty_Bool) → new_esEs19(vxw312, vxw4012)
new_esEs31(vxw30, vxw400, ty_Int) → new_esEs12(vxw30, vxw400)
new_ltEs8(GT, LT) → False
new_esEs7(@3(vxw310, vxw311, vxw312), @3(vxw4010, vxw4011, vxw4012), bed, bee, bef) → new_asAs(new_esEs24(vxw310, vxw4010, bed), new_asAs(new_esEs23(vxw311, vxw4011, bee), new_esEs22(vxw312, vxw4012, bef)))
new_compare31(vxw270, vxw250, app(app(ty_Either, dae), daf)) → new_compare19(vxw270, vxw250, dae, daf)
new_lt21(vxw27, vxw25, app(ty_[], hh)) → new_lt13(vxw27, vxw25, hh)
new_esEs26(vxw280, vxw260, ty_Char) → new_esEs11(vxw280, vxw260)
new_compare10(:%(vxw270, vxw271), :%(vxw250, vxw251), ty_Int) → new_compare6(new_sr(vxw270, vxw251), new_sr(vxw250, vxw271))
new_esEs5(Left(vxw310), Left(vxw4010), app(ty_[], ddc), dch) → new_esEs15(vxw310, vxw4010, ddc)
new_lt12(vxw27, vxw25) → new_esEs10(new_compare11(vxw27, vxw25), LT)
new_esEs26(vxw280, vxw260, ty_Float) → new_esEs16(vxw280, vxw260)
new_lt21(vxw27, vxw25, ty_Integer) → new_lt12(vxw27, vxw25)
new_primCompAux0(vxw77, LT) → LT
new_ltEs6(Left(vxw280), Left(vxw260), ty_Float, hc) → new_ltEs11(vxw280, vxw260)
new_not(False) → True
new_esEs15(:(vxw310, vxw311), :(vxw4010, vxw4011), bae) → new_asAs(new_esEs20(vxw310, vxw4010, bae), new_esEs15(vxw311, vxw4011, bae))
new_ltEs20(vxw28, vxw26, app(app(app(ty_@3, he), hf), hg)) → new_ltEs17(vxw28, vxw26, he, hf, hg)
new_compare24(vxw27, vxw25, True, gf) → EQ
new_esEs5(Right(vxw310), Right(vxw4010), dcg, ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_esEs8(vxw311, vxw4011, app(ty_Maybe, dg)) → new_esEs6(vxw311, vxw4011, dg)
new_primCmpInt(Pos(Succ(vxw2700)), Pos(vxw250)) → new_primCmpNat0(Succ(vxw2700), vxw250)
new_primPlusNat0(Zero, vxw401000) → Succ(vxw401000)
new_compare210(vxw27, vxw25, True, baa, bab) → EQ
new_ltEs10(vxw281, vxw261, ty_@0) → new_ltEs7(vxw281, vxw261)
new_ltEs9(@2(vxw280, vxw281), @2(vxw260, vxw261), gh, ha) → new_pePe(new_lt10(vxw280, vxw260, gh), new_asAs(new_esEs21(vxw280, vxw260, gh), new_ltEs10(vxw281, vxw261, ha)))
new_esEs26(vxw280, vxw260, app(ty_Ratio, cae)) → new_esEs18(vxw280, vxw260, cae)
new_ltEs17(@3(vxw280, vxw281, vxw282), @3(vxw260, vxw261, vxw262), he, hf, hg) → new_pePe(new_lt19(vxw280, vxw260, he), new_asAs(new_esEs26(vxw280, vxw260, he), new_pePe(new_lt20(vxw281, vxw261, hf), new_asAs(new_esEs25(vxw281, vxw261, hf), new_ltEs19(vxw282, vxw262, hg)))))
new_esEs16(Float(vxw310, vxw311), Float(vxw4010, vxw4011)) → new_esEs12(new_sr(vxw310, vxw4010), new_sr(vxw311, vxw4011))
new_ltEs6(Right(vxw280), Right(vxw260), hb, ty_Char) → new_ltEs18(vxw280, vxw260)
new_compare17(vxw27, vxw25, True) → LT
new_lt20(vxw281, vxw261, app(app(ty_Either, ccc), ccd)) → new_lt16(vxw281, vxw261, ccc, ccd)
new_lt20(vxw281, vxw261, app(ty_Maybe, cce)) → new_lt17(vxw281, vxw261, cce)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, app(ty_[], dee)) → new_esEs15(vxw310, vxw4010, dee)
new_ltEs10(vxw281, vxw261, app(app(ty_Either, bdf), bdg)) → new_ltEs6(vxw281, vxw261, bdf, bdg)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Int, dch) → new_esEs12(vxw310, vxw4010)
new_esEs26(vxw280, vxw260, app(app(ty_Either, cba), cbb)) → new_esEs5(vxw280, vxw260, cba, cbb)
new_ltEs20(vxw28, vxw26, app(ty_Maybe, hd)) → new_ltEs5(vxw28, vxw26, hd)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Bool, dch) → new_esEs19(vxw310, vxw4010)
new_esEs22(vxw312, vxw4012, app(app(app(ty_@3, bfd), bfe), bff)) → new_esEs7(vxw312, vxw4012, bfd, bfe, bff)
new_primCmpInt(Pos(Succ(vxw2700)), Neg(vxw250)) → GT
new_esEs8(vxw311, vxw4011, app(app(app(ty_@3, ea), eb), ec)) → new_esEs7(vxw311, vxw4011, ea, eb, ec)
new_esEs22(vxw312, vxw4012, ty_Char) → new_esEs11(vxw312, vxw4012)
new_ltEs18(vxw28, vxw26) → new_fsEs(new_compare8(vxw28, vxw26))
new_esEs26(vxw280, vxw260, ty_@0) → new_esEs17(vxw280, vxw260)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Ordering, dch) → new_esEs10(vxw310, vxw4010)
new_primMulInt(Pos(vxw3100), Pos(vxw40100)) → Pos(new_primMulNat0(vxw3100, vxw40100))
new_esEs21(vxw280, vxw260, app(app(ty_@2, bcb), bcc)) → new_esEs4(vxw280, vxw260, bcb, bcc)
new_esEs9(vxw310, vxw4010, app(ty_Ratio, fb)) → new_esEs18(vxw310, vxw4010, fb)
new_compare31(vxw270, vxw250, ty_Char) → new_compare8(vxw270, vxw250)
new_esEs5(Left(vxw310), Left(vxw4010), ty_@0, dch) → new_esEs17(vxw310, vxw4010)
new_esEs20(vxw310, vxw4010, ty_Char) → new_esEs11(vxw310, vxw4010)
new_esEs20(vxw310, vxw4010, ty_Bool) → new_esEs19(vxw310, vxw4010)
new_compare31(vxw270, vxw250, ty_Bool) → new_compare12(vxw270, vxw250)
new_esEs5(Left(vxw310), Right(vxw4010), dcg, dch) → False
new_esEs5(Right(vxw310), Left(vxw4010), dcg, dch) → False
new_primMulInt(Neg(vxw3100), Neg(vxw40100)) → Pos(new_primMulNat0(vxw3100, vxw40100))
new_ltEs5(Just(vxw280), Just(vxw260), ty_Double) → new_ltEs15(vxw280, vxw260)
new_primEqNat0(Zero, Succ(vxw40100)) → False
new_primEqNat0(Succ(vxw3100), Zero) → False
new_ltEs5(Nothing, Nothing, hd) → True
new_ltEs6(Right(vxw280), Right(vxw260), hb, ty_Float) → new_ltEs11(vxw280, vxw260)
new_compare25(vxw27, vxw25, True, bac, bad) → EQ
new_esEs25(vxw281, vxw261, app(ty_Maybe, cce)) → new_esEs6(vxw281, vxw261, cce)
new_lt21(vxw27, vxw25, ty_Ordering) → new_lt9(vxw27, vxw25)
new_esEs22(vxw312, vxw4012, ty_Double) → new_esEs14(vxw312, vxw4012)
new_primEqInt(Pos(Zero), Pos(Zero)) → True
new_esEs6(Just(vxw310), Just(vxw4010), app(ty_[], dbf)) → new_esEs15(vxw310, vxw4010, dbf)
new_esEs23(vxw311, vxw4011, app(ty_Ratio, bge)) → new_esEs18(vxw311, vxw4011, bge)
new_lt4(vxw27, vxw25) → new_esEs10(new_compare7(vxw27, vxw25), LT)
new_lt19(vxw280, vxw260, app(ty_Maybe, cbc)) → new_lt17(vxw280, vxw260, cbc)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Ordering, hc) → new_ltEs8(vxw280, vxw260)
new_esEs25(vxw281, vxw261, ty_Int) → new_esEs12(vxw281, vxw261)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Bool) → new_ltEs16(vxw280, vxw260)
new_compare31(vxw270, vxw250, app(app(ty_@2, dac), dad)) → new_compare30(vxw270, vxw250, dac, dad)
new_ltEs5(Just(vxw280), Just(vxw260), ty_Int) → new_ltEs14(vxw280, vxw260)
new_lt21(vxw27, vxw25, ty_Float) → new_lt11(vxw27, vxw25)
new_compare28(vxw27, vxw25, True, ga, gb, gc) → EQ
new_lt10(vxw280, vxw260, app(ty_Ratio, bbh)) → new_lt6(vxw280, vxw260, bbh)
new_ltEs6(Left(vxw280), Left(vxw260), app(ty_Maybe, cgc), hc) → new_ltEs5(vxw280, vxw260, cgc)
new_lt8(vxw27, vxw25) → new_esEs10(new_compare6(vxw27, vxw25), LT)
new_ltEs10(vxw281, vxw261, ty_Float) → new_ltEs11(vxw281, vxw261)
new_ltEs19(vxw282, vxw262, app(ty_Maybe, cdg)) → new_ltEs5(vxw282, vxw262, cdg)
new_lt10(vxw280, vxw260, app(app(app(ty_@3, bcg), bch), bda)) → new_lt5(vxw280, vxw260, bcg, bch, bda)
new_compare13(vxw27, vxw25, False, gf) → GT
new_compare25(vxw27, vxw25, False, bac, bad) → new_compare15(vxw27, vxw25, new_ltEs6(vxw27, vxw25, bac, bad), bac, bad)
new_esEs22(vxw312, vxw4012, app(ty_[], bfa)) → new_esEs15(vxw312, vxw4012, bfa)
new_primCmpInt(Neg(Zero), Neg(Succ(vxw2500))) → new_primCmpNat0(Succ(vxw2500), Zero)
new_lt20(vxw281, vxw261, app(app(ty_@2, cca), ccb)) → new_lt15(vxw281, vxw261, cca, ccb)
new_primCmpInt(Pos(Zero), Neg(Succ(vxw2500))) → GT
new_ltEs6(Left(vxw280), Left(vxw260), app(ty_Ratio, cfe), hc) → new_ltEs12(vxw280, vxw260, cfe)
new_esEs12(vxw31, vxw401) → new_primEqInt(vxw31, vxw401)
new_esEs29(vxw27, vxw25, ty_Bool) → new_esEs19(vxw27, vxw25)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Integer, dch) → new_esEs13(vxw310, vxw4010)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Int) → new_esEs12(vxw310, vxw4010)
new_compare31(vxw270, vxw250, app(ty_[], dab)) → new_compare(vxw270, vxw250, dab)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, ty_Double) → new_esEs14(vxw310, vxw4010)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, app(app(app(ty_@3, deh), dfa), dfb)) → new_esEs7(vxw310, vxw4010, deh, dfa, dfb)
new_compare15(vxw27, vxw25, False, bac, bad) → GT
new_ltEs5(Just(vxw280), Just(vxw260), ty_Ordering) → new_ltEs8(vxw280, vxw260)
new_esEs20(vxw310, vxw4010, app(ty_Ratio, bbb)) → new_esEs18(vxw310, vxw4010, bbb)
new_esEs15(:(vxw310, vxw311), [], bae) → False
new_esEs15([], :(vxw4010, vxw4011), bae) → False
new_compare5(Double(vxw270, vxw271), Double(vxw250, vxw251)) → new_compare6(new_sr(vxw270, vxw250), new_sr(vxw271, vxw251))
new_esEs11(Char(vxw310), Char(vxw4010)) → new_primEqNat0(vxw310, vxw4010)
new_compare16(vxw27, vxw25) → new_compare26(vxw27, vxw25, new_esEs10(vxw27, vxw25))
new_esEs6(Just(vxw310), Just(vxw4010), app(app(ty_Either, dcd), dce)) → new_esEs5(vxw310, vxw4010, dcd, dce)
new_esEs9(vxw310, vxw4010, ty_Double) → new_esEs14(vxw310, vxw4010)
new_compare32(Float(vxw270, vxw271), Float(vxw250, vxw251)) → new_compare6(new_sr(vxw270, vxw250), new_sr(vxw271, vxw251))
new_esEs9(vxw310, vxw4010, app(app(ty_@2, ef), eg)) → new_esEs4(vxw310, vxw4010, ef, eg)
new_esEs8(vxw311, vxw4011, ty_Bool) → new_esEs19(vxw311, vxw4011)
new_ltEs6(Right(vxw280), Right(vxw260), hb, app(app(ty_Either, chc), chd)) → new_ltEs6(vxw280, vxw260, chc, chd)
new_esEs8(vxw311, vxw4011, ty_Char) → new_esEs11(vxw311, vxw4011)
new_esEs24(vxw310, vxw4010, app(app(app(ty_@3, bhh), caa), cab)) → new_esEs7(vxw310, vxw4010, bhh, caa, cab)
new_primCmpInt(Neg(Zero), Neg(Zero)) → EQ
new_primCompAux1(vxw270, vxw250, vxw72, hh) → new_primCompAux0(vxw72, new_compare31(vxw270, vxw250, hh))
new_esEs20(vxw310, vxw4010, app(ty_Maybe, bba)) → new_esEs6(vxw310, vxw4010, bba)
new_esEs24(vxw310, vxw4010, ty_Char) → new_esEs11(vxw310, vxw4010)
new_asAs(False, vxw56) → False
new_lt14(vxw27, vxw25) → new_esEs10(new_compare5(vxw27, vxw25), LT)
new_esEs14(Double(vxw310, vxw311), Double(vxw4010, vxw4011)) → new_esEs12(new_sr(vxw310, vxw4010), new_sr(vxw311, vxw4011))
new_primMulInt(Neg(vxw3100), Pos(vxw40100)) → Neg(new_primMulNat0(vxw3100, vxw40100))
new_primMulInt(Pos(vxw3100), Neg(vxw40100)) → Neg(new_primMulNat0(vxw3100, vxw40100))
new_primMulNat0(Zero, Succ(vxw401000)) → Zero
new_primMulNat0(Succ(vxw31000), Zero) → Zero
new_esEs9(vxw310, vxw4010, ty_@0) → new_esEs17(vxw310, vxw4010)
new_esEs21(vxw280, vxw260, app(app(ty_Either, bcd), bce)) → new_esEs5(vxw280, vxw260, bcd, bce)
new_esEs31(vxw30, vxw400, ty_Ordering) → new_esEs10(vxw30, vxw400)
new_esEs26(vxw280, vxw260, ty_Integer) → new_esEs13(vxw280, vxw260)
new_esEs6(Just(vxw310), Just(vxw4010), app(ty_Maybe, dbg)) → new_esEs6(vxw310, vxw4010, dbg)
new_lt21(vxw27, vxw25, app(ty_Maybe, gf)) → new_lt17(vxw27, vxw25, gf)
new_ltEs6(Left(vxw280), Left(vxw260), app(app(ty_@2, cfg), cfh), hc) → new_ltEs9(vxw280, vxw260, cfg, cfh)
new_esEs10(GT, GT) → True
new_esEs25(vxw281, vxw261, ty_Ordering) → new_esEs10(vxw281, vxw261)
new_lt19(vxw280, vxw260, app(app(ty_@2, cag), cah)) → new_lt15(vxw280, vxw260, cag, cah)
new_ltEs10(vxw281, vxw261, app(ty_Maybe, bdh)) → new_ltEs5(vxw281, vxw261, bdh)
new_esEs20(vxw310, vxw4010, ty_Float) → new_esEs16(vxw310, vxw4010)
new_compare11(Integer(vxw270), Integer(vxw250)) → new_primCmpInt(vxw270, vxw250)
new_ltEs5(Just(vxw280), Just(vxw260), app(ty_Maybe, cfa)) → new_ltEs5(vxw280, vxw260, cfa)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_lt21(vxw27, vxw25, app(app(ty_@2, baa), bab)) → new_lt15(vxw27, vxw25, baa, bab)
new_esEs6(Just(vxw310), Just(vxw4010), app(app(ty_@2, dbd), dbe)) → new_esEs4(vxw310, vxw4010, dbd, dbe)
new_compare110(vxw27, vxw25, True, ga, gb, gc) → LT
new_esEs23(vxw311, vxw4011, app(ty_Maybe, bgd)) → new_esEs6(vxw311, vxw4011, bgd)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Ordering) → new_esEs10(vxw310, vxw4010)
new_esEs25(vxw281, vxw261, ty_Integer) → new_esEs13(vxw281, vxw261)
new_esEs20(vxw310, vxw4010, app(ty_[], bah)) → new_esEs15(vxw310, vxw4010, bah)
new_ltEs20(vxw28, vxw26, app(ty_Ratio, gg)) → new_ltEs12(vxw28, vxw26, gg)
new_esEs28(vxw310, vxw4010, ty_Integer) → new_esEs13(vxw310, vxw4010)
new_esEs8(vxw311, vxw4011, app(ty_Ratio, dh)) → new_esEs18(vxw311, vxw4011, dh)
new_esEs20(vxw310, vxw4010, app(app(ty_@2, baf), bag)) → new_esEs4(vxw310, vxw4010, baf, bag)
new_esEs30(vxw31, vxw401, app(app(ty_Either, dcg), dch)) → new_esEs5(vxw31, vxw401, dcg, dch)
new_compare27(vxw27, vxw25, True) → EQ
new_esEs29(vxw27, vxw25, ty_Ordering) → new_esEs10(vxw27, vxw25)
new_ltEs6(Right(vxw280), Right(vxw260), hb, ty_Int) → new_ltEs14(vxw280, vxw260)
new_ltEs8(LT, GT) → True
new_esEs5(Right(vxw310), Right(vxw4010), dcg, app(ty_Maybe, def)) → new_esEs6(vxw310, vxw4010, def)
new_esEs26(vxw280, vxw260, app(ty_[], caf)) → new_esEs15(vxw280, vxw260, caf)
new_esEs22(vxw312, vxw4012, ty_Float) → new_esEs16(vxw312, vxw4012)
new_esEs25(vxw281, vxw261, app(app(app(ty_@3, ccf), ccg), cch)) → new_esEs7(vxw281, vxw261, ccf, ccg, cch)
new_esEs31(vxw30, vxw400, ty_Char) → new_esEs11(vxw30, vxw400)
new_compare31(vxw270, vxw250, ty_Double) → new_compare5(vxw270, vxw250)
new_esEs30(vxw31, vxw401, ty_Int) → new_esEs12(vxw31, vxw401)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, ty_Int) → new_esEs12(vxw310, vxw4010)
new_lt10(vxw280, vxw260, ty_Double) → new_lt14(vxw280, vxw260)
new_ltEs20(vxw28, vxw26, ty_Float) → new_ltEs11(vxw28, vxw26)
new_esEs20(vxw310, vxw4010, ty_Int) → new_esEs12(vxw310, vxw4010)
new_ltEs6(Left(vxw280), Left(vxw260), app(ty_[], cff), hc) → new_ltEs4(vxw280, vxw260, cff)
new_lt20(vxw281, vxw261, ty_Integer) → new_lt12(vxw281, vxw261)
new_lt20(vxw281, vxw261, ty_Float) → new_lt11(vxw281, vxw261)
new_compare26(vxw27, vxw25, False) → new_compare17(vxw27, vxw25, new_ltEs8(vxw27, vxw25))
new_ltEs6(Right(vxw280), Right(vxw260), hb, ty_Ordering) → new_ltEs8(vxw280, vxw260)
new_esEs30(vxw31, vxw401, ty_Ordering) → new_esEs10(vxw31, vxw401)
new_lt10(vxw280, vxw260, ty_Int) → new_lt8(vxw280, vxw260)
new_ltEs6(Right(vxw280), Right(vxw260), hb, ty_Double) → new_ltEs15(vxw280, vxw260)
new_esEs5(Left(vxw310), Left(vxw4010), app(app(ty_Either, dea), deb), dch) → new_esEs5(vxw310, vxw4010, dea, deb)
new_ltEs19(vxw282, vxw262, app(app(app(ty_@3, cdh), cea), ceb)) → new_ltEs17(vxw282, vxw262, cdh, cea, ceb)
new_esEs6(Just(vxw310), Just(vxw4010), ty_Float) → new_esEs16(vxw310, vxw4010)
new_compare14(vxw27, vxw25, True, baa, bab) → LT
new_esEs10(GT, LT) → False
new_esEs10(LT, GT) → False
new_ltEs19(vxw282, vxw262, ty_Double) → new_ltEs15(vxw282, vxw262)
new_esEs10(EQ, LT) → False
new_esEs10(LT, EQ) → False
new_lt20(vxw281, vxw261, app(app(app(ty_@3, ccf), ccg), cch)) → new_lt5(vxw281, vxw261, ccf, ccg, cch)
new_ltEs6(Right(vxw280), Right(vxw260), hb, app(ty_[], cgh)) → new_ltEs4(vxw280, vxw260, cgh)
new_ltEs8(LT, LT) → True
new_esEs28(vxw310, vxw4010, ty_Int) → new_esEs12(vxw310, vxw4010)
new_primPlusNat1(Zero, Zero) → Zero
new_ltEs6(Right(vxw280), Right(vxw260), hb, ty_Bool) → new_ltEs16(vxw280, vxw260)
new_lt21(vxw27, vxw25, app(ty_Ratio, ge)) → new_lt6(vxw27, vxw25, ge)
new_esEs31(vxw30, vxw400, ty_Double) → new_esEs14(vxw30, vxw400)
new_asAs(True, vxw56) → vxw56
new_esEs24(vxw310, vxw4010, ty_Float) → new_esEs16(vxw310, vxw4010)
new_esEs5(Right(vxw310), Right(vxw4010), dcg, ty_Char) → new_esEs11(vxw310, vxw4010)
new_ltEs7(vxw28, vxw26) → new_fsEs(new_compare7(vxw28, vxw26))
new_primMulNat0(Succ(vxw31000), Succ(vxw401000)) → new_primPlusNat0(new_primMulNat0(vxw31000, Succ(vxw401000)), vxw401000)
new_ltEs16(False, False) → True
new_lt10(vxw280, vxw260, ty_Ordering) → new_lt9(vxw280, vxw260)
new_esEs5(Left(vxw310), Left(vxw4010), ty_Float, dch) → new_esEs16(vxw310, vxw4010)
new_compare17(vxw27, vxw25, False) → GT
new_esEs22(vxw312, vxw4012, ty_Ordering) → new_esEs10(vxw312, vxw4012)
new_lt10(vxw280, vxw260, app(ty_Maybe, bcf)) → new_lt17(vxw280, vxw260, bcf)
new_ltEs6(Right(vxw280), Right(vxw260), hb, ty_@0) → new_ltEs7(vxw280, vxw260)
new_compare31(vxw270, vxw250, app(ty_Ratio, daa)) → new_compare10(vxw270, vxw250, daa)
new_ltEs10(vxw281, vxw261, ty_Integer) → new_ltEs13(vxw281, vxw261)
new_ltEs19(vxw282, vxw262, ty_Integer) → new_ltEs13(vxw282, vxw262)
new_lt21(vxw27, vxw25, ty_Double) → new_lt14(vxw27, vxw25)
new_ltEs5(Just(vxw280), Just(vxw260), app(ty_[], ced)) → new_ltEs4(vxw280, vxw260, ced)
new_esEs29(vxw27, vxw25, app(ty_[], hh)) → new_esEs15(vxw27, vxw25, hh)
new_ltEs6(Left(vxw280), Left(vxw260), ty_Bool, hc) → new_ltEs16(vxw280, vxw260)
new_ltEs11(vxw28, vxw26) → new_fsEs(new_compare32(vxw28, vxw26))
new_ltEs13(vxw28, vxw26) → new_fsEs(new_compare11(vxw28, vxw26))
new_lt19(vxw280, vxw260, ty_Double) → new_lt14(vxw280, vxw260)
new_esEs24(vxw310, vxw4010, app(ty_Maybe, bhf)) → new_esEs6(vxw310, vxw4010, bhf)
new_esEs30(vxw31, vxw401, ty_Double) → new_esEs14(vxw31, vxw401)
new_ltEs10(vxw281, vxw261, ty_Ordering) → new_ltEs8(vxw281, vxw261)
new_ltEs10(vxw281, vxw261, ty_Int) → new_ltEs14(vxw281, vxw261)
new_esEs30(vxw31, vxw401, app(ty_[], bae)) → new_esEs15(vxw31, vxw401, bae)
new_compare110(vxw27, vxw25, False, ga, gb, gc) → GT
new_esEs22(vxw312, vxw4012, app(app(ty_Either, bfg), bfh)) → new_esEs5(vxw312, vxw4012, bfg, bfh)
new_compare8(Char(vxw270), Char(vxw250)) → new_primCmpNat0(vxw270, vxw250)
new_esEs31(vxw30, vxw400, app(ty_Maybe, cb)) → new_esEs6(vxw30, vxw400, cb)
new_esEs21(vxw280, vxw260, ty_Float) → new_esEs16(vxw280, vxw260)
new_primCmpInt(Pos(Zero), Pos(Zero)) → EQ
new_primCompAux0(vxw77, EQ) → vxw77
new_ltEs19(vxw282, vxw262, app(app(ty_Either, cde), cdf)) → new_ltEs6(vxw282, vxw262, cde, cdf)
new_esEs24(vxw310, vxw4010, app(ty_[], bhe)) → new_esEs15(vxw310, vxw4010, bhe)
new_primEqInt(Pos(Zero), Neg(Zero)) → True
new_primEqInt(Neg(Zero), Pos(Zero)) → True
new_esEs30(vxw31, vxw401, app(app(ty_@2, db), dc)) → new_esEs4(vxw31, vxw401, db, dc)
new_esEs21(vxw280, vxw260, app(ty_Ratio, bbh)) → new_esEs18(vxw280, vxw260, bbh)
new_primCmpInt(Neg(Succ(vxw2700)), Pos(vxw250)) → LT
new_esEs30(vxw31, vxw401, ty_Bool) → new_esEs19(vxw31, vxw401)
new_esEs24(vxw310, vxw4010, ty_Double) → new_esEs14(vxw310, vxw4010)
new_not(True) → False
new_esEs6(Just(vxw310), Just(vxw4010), app(ty_Ratio, dbh)) → new_esEs18(vxw310, vxw4010, dbh)

The set Q consists of the following terms:

new_ltEs14(x0, x1)
new_esEs22(x0, x1, ty_Int)
new_esEs4(@2(x0, x1), @2(x2, x3), x4, x5)
new_compare210(x0, x1, True, x2, x3)
new_esEs26(x0, x1, app(app(ty_Either, x2), x3))
new_compare14(x0, x1, False, x2, x3)
new_lt20(x0, x1, app(ty_[], x2))
new_primEqNat0(Zero, Succ(x0))
new_lt20(x0, x1, ty_Char)
new_esEs5(Left(x0), Left(x1), ty_Ordering, x2)
new_esEs21(x0, x1, ty_Ordering)
new_ltEs16(True, True)
new_lt21(x0, x1, ty_Double)
new_ltEs6(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_esEs22(x0, x1, app(ty_Ratio, x2))
new_ltEs5(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_lt21(x0, x1, app(ty_Maybe, x2))
new_ltEs20(x0, x1, ty_Ordering)
new_esEs23(x0, x1, ty_Int)
new_esEs5(Right(x0), Right(x1), x2, ty_Ordering)
new_esEs5(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_lt20(x0, x1, app(app(ty_@2, x2), x3))
new_compare210(x0, x1, False, x2, x3)
new_ltEs8(EQ, EQ)
new_esEs9(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primMulInt(Pos(x0), Pos(x1))
new_lt10(x0, x1, app(ty_[], x2))
new_esEs20(x0, x1, ty_Char)
new_esEs31(x0, x1, ty_Int)
new_lt19(x0, x1, ty_Bool)
new_esEs6(Just(x0), Just(x1), app(ty_Maybe, x2))
new_esEs6(Just(x0), Just(x1), ty_Bool)
new_esEs5(Left(x0), Left(x1), ty_@0, x2)
new_esEs22(x0, x1, ty_Bool)
new_ltEs5(Just(x0), Nothing, x1)
new_lt21(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs5(Nothing, Nothing, x0)
new_esEs8(x0, x1, ty_Char)
new_esEs5(Right(x0), Right(x1), x2, ty_Char)
new_compare13(x0, x1, False, x2)
new_primCmpInt(Neg(Succ(x0)), Pos(x1))
new_primCmpInt(Pos(Succ(x0)), Neg(x1))
new_ltEs6(Left(x0), Left(x1), ty_Double, x2)
new_primPlusNat1(Succ(x0), Zero)
new_ltEs5(Just(x0), Just(x1), ty_Bool)
new_compare31(x0, x1, app(app(ty_Either, x2), x3))
new_lt21(x0, x1, app(ty_[], x2))
new_esEs8(x0, x1, app(ty_Ratio, x2))
new_primPlusNat1(Zero, Succ(x0))
new_esEs10(GT, EQ)
new_esEs10(EQ, GT)
new_compare16(x0, x1)
new_esEs26(x0, x1, app(app(ty_@2, x2), x3))
new_esEs10(EQ, LT)
new_esEs10(LT, EQ)
new_esEs22(x0, x1, app(app(ty_@2, x2), x3))
new_esEs6(Just(x0), Just(x1), ty_Float)
new_esEs26(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs23(x0, x1, app(app(ty_Either, x2), x3))
new_primEqInt(Neg(Zero), Neg(Succ(x0)))
new_primMulInt(Neg(x0), Neg(x1))
new_primMulNat0(Succ(x0), Succ(x1))
new_lt11(x0, x1)
new_primEqInt(Pos(Succ(x0)), Pos(Succ(x1)))
new_esEs9(x0, x1, ty_Float)
new_ltEs5(Just(x0), Just(x1), ty_Char)
new_ltEs6(Left(x0), Left(x1), ty_Float, x2)
new_esEs8(x0, x1, ty_Bool)
new_ltEs19(x0, x1, ty_Integer)
new_lt21(x0, x1, ty_@0)
new_ltEs20(x0, x1, ty_Bool)
new_ltEs6(Right(x0), Right(x1), x2, ty_@0)
new_lt20(x0, x1, ty_Int)
new_esEs25(x0, x1, app(ty_[], x2))
new_esEs15([], [], x0)
new_esEs27(x0, x1, ty_Integer)
new_esEs31(x0, x1, app(ty_Ratio, x2))
new_lt19(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs6(Just(x0), Nothing, x1)
new_esEs5(Left(x0), Left(x1), ty_Integer, x2)
new_ltEs10(x0, x1, ty_Double)
new_esEs31(x0, x1, ty_Char)
new_esEs5(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_ltEs5(Just(x0), Just(x1), ty_Float)
new_ltEs20(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs10(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs5(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_ltEs5(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_lt14(x0, x1)
new_esEs19(True, True)
new_lt6(x0, x1, x2)
new_ltEs19(x0, x1, ty_@0)
new_ltEs10(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare31(x0, x1, ty_Bool)
new_ltEs10(x0, x1, ty_Bool)
new_esEs22(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_lt10(x0, x1, app(app(ty_@2, x2), x3))
new_lt20(x0, x1, ty_Ordering)
new_esEs26(x0, x1, ty_Integer)
new_ltEs10(x0, x1, ty_Ordering)
new_primMulNat0(Zero, Succ(x0))
new_esEs31(x0, x1, ty_Double)
new_ltEs6(Left(x0), Left(x1), ty_Int, x2)
new_esEs25(x0, x1, ty_@0)
new_esEs25(x0, x1, ty_Int)
new_esEs21(x0, x1, app(app(ty_Either, x2), x3))
new_esEs26(x0, x1, ty_Ordering)
new_primEqNat0(Zero, Zero)
new_lt21(x0, x1, app(app(ty_@2, x2), x3))
new_esEs5(Left(x0), Left(x1), ty_Char, x2)
new_esEs30(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs8(x0, x1, app(ty_Maybe, x2))
new_lt16(x0, x1, x2, x3)
new_esEs25(x0, x1, app(app(ty_Either, x2), x3))
new_esEs6(Nothing, Just(x0), x1)
new_lt21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare(:(x0, x1), :(x2, x3), x4)
new_ltEs6(Left(x0), Left(x1), ty_Char, x2)
new_lt19(x0, x1, ty_Char)
new_lt19(x0, x1, ty_@0)
new_esEs30(x0, x1, ty_Bool)
new_esEs8(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs6(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_esEs9(x0, x1, app(ty_Ratio, x2))
new_esEs6(Just(x0), Just(x1), app(ty_Ratio, x2))
new_ltEs6(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_esEs29(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs11(x0, x1)
new_pePe(True, x0)
new_lt18(x0, x1)
new_ltEs5(Just(x0), Just(x1), ty_Ordering)
new_pePe(False, x0)
new_ltEs10(x0, x1, app(ty_Ratio, x2))
new_esEs26(x0, x1, ty_Float)
new_primMulNat0(Zero, Zero)
new_compare31(x0, x1, ty_Int)
new_ltEs19(x0, x1, ty_Double)
new_esEs22(x0, x1, ty_Float)
new_compare31(x0, x1, ty_Char)
new_esEs31(x0, x1, app(ty_Maybe, x2))
new_esEs23(x0, x1, ty_@0)
new_ltEs5(Just(x0), Just(x1), app(ty_Ratio, x2))
new_esEs20(x0, x1, ty_Bool)
new_compare31(x0, x1, ty_Integer)
new_ltEs6(Left(x0), Left(x1), app(ty_[], x2), x3)
new_esEs6(Just(x0), Just(x1), ty_Integer)
new_esEs21(x0, x1, app(ty_Maybe, x2))
new_esEs20(x0, x1, ty_Int)
new_compare31(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs9(x0, x1, app(app(ty_Either, x2), x3))
new_esEs26(x0, x1, app(ty_[], x2))
new_lt10(x0, x1, app(app(ty_Either, x2), x3))
new_esEs6(Just(x0), Just(x1), app(app(ty_Either, x2), x3))
new_esEs20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs6(Right(x0), Right(x1), x2, ty_Int)
new_lt10(x0, x1, ty_@0)
new_esEs29(x0, x1, ty_Float)
new_esEs9(x0, x1, ty_@0)
new_esEs30(x0, x1, ty_Ordering)
new_ltEs20(x0, x1, app(ty_Ratio, x2))
new_primCmpInt(Neg(Succ(x0)), Neg(x1))
new_esEs10(GT, LT)
new_esEs10(LT, GT)
new_primCmpNat0(Succ(x0), Zero)
new_esEs6(Just(x0), Just(x1), app(app(ty_@2, x2), x3))
new_primCompAux0(x0, GT)
new_esEs28(x0, x1, ty_Int)
new_esEs20(x0, x1, app(ty_[], x2))
new_esEs30(x0, x1, ty_Double)
new_esEs26(x0, x1, ty_Char)
new_lt4(x0, x1)
new_asAs(False, x0)
new_lt10(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs10(x0, x1, ty_Int)
new_ltEs10(x0, x1, app(ty_[], x2))
new_esEs30(x0, x1, app(app(ty_Either, x2), x3))
new_esEs9(x0, x1, ty_Double)
new_lt20(x0, x1, app(ty_Maybe, x2))
new_esEs5(Right(x0), Right(x1), x2, ty_Integer)
new_lt21(x0, x1, ty_Bool)
new_lt15(x0, x1, x2, x3)
new_esEs30(x0, x1, ty_@0)
new_esEs20(x0, x1, app(ty_Maybe, x2))
new_esEs22(x0, x1, app(app(ty_Either, x2), x3))
new_esEs29(x0, x1, app(app(ty_Either, x2), x3))
new_primEqInt(Neg(Zero), Pos(Succ(x0)))
new_primEqInt(Pos(Zero), Neg(Succ(x0)))
new_ltEs6(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_esEs6(Just(x0), Just(x1), ty_Int)
new_asAs(True, x0)
new_esEs5(Right(x0), Right(x1), x2, ty_@0)
new_ltEs20(x0, x1, app(ty_Maybe, x2))
new_lt21(x0, x1, ty_Int)
new_esEs22(x0, x1, ty_Double)
new_esEs29(x0, x1, ty_Integer)
new_compare30(x0, x1, x2, x3)
new_esEs23(x0, x1, ty_Bool)
new_ltEs9(@2(x0, x1), @2(x2, x3), x4, x5)
new_esEs21(x0, x1, ty_Int)
new_esEs31(x0, x1, app(app(ty_Either, x2), x3))
new_esEs29(x0, x1, ty_Char)
new_compare31(x0, x1, app(ty_Maybe, x2))
new_esEs21(x0, x1, ty_Bool)
new_esEs25(x0, x1, ty_Float)
new_esEs23(x0, x1, ty_Integer)
new_esEs7(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_lt21(x0, x1, app(ty_Ratio, x2))
new_esEs19(True, False)
new_esEs19(False, True)
new_ltEs6(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_esEs26(x0, x1, ty_@0)
new_primPlusNat1(Zero, Zero)
new_esEs9(x0, x1, app(ty_Maybe, x2))
new_esEs26(x0, x1, ty_Bool)
new_lt21(x0, x1, ty_Float)
new_esEs29(x0, x1, app(ty_Maybe, x2))
new_esEs26(x0, x1, app(ty_Maybe, x2))
new_ltEs19(x0, x1, ty_Bool)
new_primEqInt(Neg(Succ(x0)), Pos(x1))
new_primEqInt(Pos(Succ(x0)), Neg(x1))
new_compare18(x0, x1, False)
new_compare13(x0, x1, True, x2)
new_ltEs20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_compare31(x0, x1, ty_Double)
new_lt21(x0, x1, ty_Ordering)
new_ltEs10(x0, x1, ty_Char)
new_esEs10(EQ, EQ)
new_lt10(x0, x1, ty_Float)
new_esEs21(x0, x1, ty_Float)
new_esEs9(x0, x1, ty_Int)
new_esEs5(Right(x0), Right(x1), x2, ty_Int)
new_primCmpInt(Neg(Zero), Neg(Zero))
new_ltEs6(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_lt17(x0, x1, x2)
new_esEs23(x0, x1, ty_Float)
new_esEs5(Left(x0), Left(x1), app(ty_Maybe, x2), x3)
new_primCmpInt(Pos(Zero), Pos(Succ(x0)))
new_lt20(x0, x1, ty_Integer)
new_ltEs18(x0, x1)
new_esEs27(x0, x1, ty_Int)
new_esEs24(x0, x1, app(app(ty_Either, x2), x3))
new_esEs29(x0, x1, ty_Double)
new_esEs24(x0, x1, ty_Ordering)
new_esEs17(@0, @0)
new_esEs24(x0, x1, app(ty_[], x2))
new_ltEs6(Left(x0), Left(x1), ty_@0, x2)
new_esEs5(Right(x0), Right(x1), x2, app(ty_[], x3))
new_esEs30(x0, x1, ty_Int)
new_esEs20(x0, x1, ty_@0)
new_esEs5(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_esEs31(x0, x1, ty_Ordering)
new_esEs9(x0, x1, ty_Bool)
new_ltEs6(Right(x0), Right(x1), x2, ty_Double)
new_ltEs19(x0, x1, app(ty_[], x2))
new_lt13(x0, x1, x2)
new_esEs21(x0, x1, ty_Integer)
new_ltEs5(Just(x0), Just(x1), ty_@0)
new_ltEs19(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs5(Just(x0), Just(x1), app(ty_Maybe, x2))
new_esEs5(Left(x0), Left(x1), ty_Float, x2)
new_lt20(x0, x1, ty_@0)
new_primCompAux0(x0, LT)
new_esEs25(x0, x1, ty_Ordering)
new_compare([], [], x0)
new_esEs30(x0, x1, app(ty_Ratio, x2))
new_esEs5(Right(x0), Right(x1), x2, ty_Double)
new_esEs8(x0, x1, ty_@0)
new_ltEs6(Right(x0), Right(x1), x2, ty_Integer)
new_compare17(x0, x1, True)
new_compare31(x0, x1, app(ty_[], x2))
new_primEqInt(Pos(Zero), Neg(Zero))
new_primEqInt(Neg(Zero), Pos(Zero))
new_lt8(x0, x1)
new_compare14(x0, x1, True, x2, x3)
new_compare25(x0, x1, False, x2, x3)
new_ltEs19(x0, x1, ty_Float)
new_lt10(x0, x1, app(ty_Maybe, x2))
new_esEs23(x0, x1, app(ty_Maybe, x2))
new_ltEs6(Left(x0), Left(x1), app(ty_Ratio, x2), x3)
new_ltEs19(x0, x1, app(app(ty_Either, x2), x3))
new_ltEs19(x0, x1, ty_Int)
new_esEs5(Left(x0), Left(x1), ty_Double, x2)
new_ltEs10(x0, x1, app(app(ty_Either, x2), x3))
new_esEs31(x0, x1, app(ty_[], x2))
new_esEs20(x0, x1, app(ty_Ratio, x2))
new_esEs9(x0, x1, ty_Ordering)
new_esEs20(x0, x1, ty_Double)
new_ltEs6(Right(x0), Right(x1), x2, ty_Float)
new_esEs8(x0, x1, ty_Double)
new_ltEs8(EQ, LT)
new_ltEs8(LT, EQ)
new_compare32(Float(x0, x1), Float(x2, x3))
new_compare17(x0, x1, False)
new_esEs23(x0, x1, ty_Double)
new_esEs19(False, False)
new_primCmpInt(Pos(Zero), Pos(Zero))
new_lt12(x0, x1)
new_esEs30(x0, x1, app(ty_Maybe, x2))
new_compare110(x0, x1, False, x2, x3, x4)
new_lt10(x0, x1, ty_Bool)
new_lt19(x0, x1, ty_Float)
new_esEs30(x0, x1, app(app(ty_@2, x2), x3))
new_primEqInt(Neg(Zero), Neg(Zero))
new_compare19(x0, x1, x2, x3)
new_ltEs6(Right(x0), Right(x1), x2, ty_Char)
new_compare24(x0, x1, True, x2)
new_esEs24(x0, x1, app(ty_Maybe, x2))
new_lt20(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs25(x0, x1, ty_Integer)
new_esEs9(x0, x1, ty_Char)
new_esEs8(x0, x1, ty_Int)
new_primCompAux0(x0, EQ)
new_ltEs19(x0, x1, app(app(ty_@2, x2), x3))
new_primEqInt(Pos(Succ(x0)), Pos(Zero))
new_ltEs20(x0, x1, app(app(ty_Either, x2), x3))
new_esEs25(x0, x1, app(app(ty_@2, x2), x3))
new_esEs12(x0, x1)
new_compare7(@0, @0)
new_compare31(x0, x1, ty_Float)
new_lt20(x0, x1, app(ty_Ratio, x2))
new_primCompAux1(x0, x1, x2, x3)
new_esEs15(:(x0, x1), :(x2, x3), x4)
new_esEs30(x0, x1, ty_Integer)
new_esEs25(x0, x1, ty_Bool)
new_ltEs5(Just(x0), Just(x1), app(ty_[], x2))
new_sr(x0, x1)
new_esEs8(x0, x1, app(app(ty_Either, x2), x3))
new_esEs18(:%(x0, x1), :%(x2, x3), x4)
new_esEs9(x0, x1, app(app(ty_@2, x2), x3))
new_esEs10(LT, LT)
new_esEs6(Just(x0), Just(x1), ty_Char)
new_ltEs5(Nothing, Just(x0), x1)
new_ltEs6(Left(x0), Left(x1), ty_Integer, x2)
new_esEs23(x0, x1, app(ty_Ratio, x2))
new_primEqNat0(Succ(x0), Succ(x1))
new_compare31(x0, x1, app(ty_Ratio, x2))
new_primEqInt(Pos(Zero), Pos(Succ(x0)))
new_esEs22(x0, x1, ty_Integer)
new_ltEs16(False, True)
new_ltEs16(True, False)
new_ltEs20(x0, x1, ty_Int)
new_compare25(x0, x1, True, x2, x3)
new_primEqNat0(Succ(x0), Zero)
new_esEs26(x0, x1, ty_Double)
new_esEs6(Just(x0), Just(x1), app(app(app(ty_@3, x2), x3), x4))
new_ltEs10(x0, x1, app(ty_Maybe, x2))
new_lt20(x0, x1, ty_Float)
new_ltEs6(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_compare15(x0, x1, True, x2, x3)
new_compare(:(x0, x1), [], x2)
new_esEs6(Just(x0), Just(x1), ty_Ordering)
new_compare10(:%(x0, x1), :%(x2, x3), ty_Integer)
new_esEs14(Double(x0, x1), Double(x2, x3))
new_fsEs(x0)
new_ltEs8(LT, LT)
new_primCmpNat0(Zero, Zero)
new_esEs31(x0, x1, app(app(ty_@2, x2), x3))
new_esEs9(x0, x1, ty_Integer)
new_lt19(x0, x1, app(ty_Ratio, x2))
new_lt9(x0, x1)
new_esEs31(x0, x1, ty_Integer)
new_ltEs20(x0, x1, ty_Char)
new_esEs22(x0, x1, app(ty_Maybe, x2))
new_ltEs8(GT, GT)
new_primCmpInt(Pos(Succ(x0)), Pos(x1))
new_lt20(x0, x1, ty_Double)
new_esEs31(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs5(Left(x0), Left(x1), ty_Int, x2)
new_ltEs19(x0, x1, ty_Char)
new_compare26(x0, x1, False)
new_esEs29(x0, x1, ty_Ordering)
new_esEs15(:(x0, x1), [], x2)
new_esEs20(x0, x1, ty_Ordering)
new_ltEs13(x0, x1)
new_esEs20(x0, x1, ty_Float)
new_ltEs10(x0, x1, ty_Float)
new_ltEs15(x0, x1)
new_ltEs19(x0, x1, ty_Ordering)
new_lt7(x0, x1)
new_compare27(x0, x1, True)
new_esEs21(x0, x1, ty_Char)
new_esEs22(x0, x1, ty_Ordering)
new_lt10(x0, x1, ty_Char)
new_primPlusNat0(Succ(x0), x1)
new_esEs26(x0, x1, ty_Int)
new_primPlusNat0(Zero, x0)
new_compare8(Char(x0), Char(x1))
new_esEs30(x0, x1, app(ty_[], x2))
new_esEs24(x0, x1, ty_Bool)
new_esEs25(x0, x1, app(ty_Ratio, x2))
new_lt19(x0, x1, app(ty_[], x2))
new_esEs24(x0, x1, app(ty_Ratio, x2))
new_esEs29(x0, x1, ty_Bool)
new_esEs21(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs24(x0, x1, ty_Char)
new_lt10(x0, x1, ty_Integer)
new_esEs10(GT, GT)
new_ltEs10(x0, x1, ty_Integer)
new_lt19(x0, x1, app(ty_Maybe, x2))
new_esEs23(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primCmpInt(Pos(Zero), Neg(Succ(x0)))
new_primCmpInt(Neg(Zero), Pos(Succ(x0)))
new_sr0(Integer(x0), Integer(x1))
new_esEs5(Left(x0), Left(x1), app(app(ty_Either, x2), x3), x4)
new_esEs23(x0, x1, ty_Ordering)
new_esEs5(Right(x0), Left(x1), x2, x3)
new_esEs5(Left(x0), Right(x1), x2, x3)
new_esEs13(Integer(x0), Integer(x1))
new_ltEs8(LT, GT)
new_ltEs8(GT, LT)
new_compare26(x0, x1, True)
new_lt20(x0, x1, app(app(ty_Either, x2), x3))
new_primMulNat0(Succ(x0), Zero)
new_lt10(x0, x1, app(ty_Ratio, x2))
new_esEs31(x0, x1, ty_@0)
new_esEs24(x0, x1, ty_@0)
new_esEs5(Left(x0), Left(x1), ty_Bool, x2)
new_ltEs10(x0, x1, ty_@0)
new_esEs28(x0, x1, ty_Integer)
new_esEs6(Just(x0), Just(x1), ty_Double)
new_primCmpNat0(Succ(x0), Succ(x1))
new_esEs5(Left(x0), Left(x1), app(ty_[], x2), x3)
new_esEs30(x0, x1, ty_Float)
new_ltEs6(Left(x0), Left(x1), ty_Ordering, x2)
new_compare24(x0, x1, False, x2)
new_esEs29(x0, x1, ty_@0)
new_ltEs17(@3(x0, x1, x2), @3(x3, x4, x5), x6, x7, x8)
new_lt10(x0, x1, ty_Double)
new_primCmpInt(Neg(Zero), Neg(Succ(x0)))
new_lt20(x0, x1, ty_Bool)
new_ltEs6(Right(x0), Right(x1), x2, ty_Ordering)
new_not(True)
new_compare10(:%(x0, x1), :%(x2, x3), ty_Int)
new_lt21(x0, x1, ty_Integer)
new_esEs8(x0, x1, app(ty_[], x2))
new_esEs5(Right(x0), Right(x1), x2, ty_Bool)
new_compare110(x0, x1, True, x2, x3, x4)
new_compare31(x0, x1, ty_Ordering)
new_esEs16(Float(x0, x1), Float(x2, x3))
new_esEs29(x0, x1, ty_Int)
new_compare31(x0, x1, ty_@0)
new_compare9(x0, x1, x2, x3, x4)
new_esEs5(Right(x0), Right(x1), x2, app(ty_Ratio, x3))
new_esEs8(x0, x1, ty_Ordering)
new_primCmpInt(Pos(Zero), Neg(Zero))
new_primCmpInt(Neg(Zero), Pos(Zero))
new_not(False)
new_lt10(x0, x1, ty_Ordering)
new_compare28(x0, x1, False, x2, x3, x4)
new_compare15(x0, x1, False, x2, x3)
new_esEs8(x0, x1, ty_Float)
new_esEs5(Right(x0), Right(x1), x2, app(app(ty_Either, x3), x4))
new_esEs22(x0, x1, ty_Char)
new_esEs26(x0, x1, app(ty_Ratio, x2))
new_lt5(x0, x1, x2, x3, x4)
new_ltEs20(x0, x1, app(ty_[], x2))
new_ltEs19(x0, x1, app(ty_Ratio, x2))
new_lt21(x0, x1, ty_Char)
new_lt19(x0, x1, ty_Integer)
new_esEs29(x0, x1, app(ty_[], x2))
new_primPlusNat1(Succ(x0), Succ(x1))
new_esEs25(x0, x1, app(ty_Maybe, x2))
new_ltEs6(Left(x0), Left(x1), app(app(app(ty_@3, x2), x3), x4), x5)
new_lt19(x0, x1, app(app(ty_@2, x2), x3))
new_primEqInt(Neg(Succ(x0)), Neg(Succ(x1)))
new_esEs5(Right(x0), Right(x1), x2, app(app(app(ty_@3, x3), x4), x5))
new_esEs5(Right(x0), Right(x1), x2, app(ty_Maybe, x3))
new_primEqInt(Neg(Succ(x0)), Neg(Zero))
new_esEs21(x0, x1, app(ty_Ratio, x2))
new_ltEs6(Left(x0), Left(x1), app(app(ty_@2, x2), x3), x4)
new_ltEs20(x0, x1, ty_Integer)
new_compare31(x0, x1, app(app(ty_@2, x2), x3))
new_ltEs6(Right(x0), Right(x1), x2, app(ty_[], x3))
new_esEs24(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs9(x0, x1, app(ty_[], x2))
new_esEs29(x0, x1, app(ty_Ratio, x2))
new_ltEs20(x0, x1, ty_Float)
new_compare11(Integer(x0), Integer(x1))
new_compare6(x0, x1)
new_esEs25(x0, x1, ty_Char)
new_compare12(x0, x1)
new_esEs15([], :(x0, x1), x2)
new_esEs6(Just(x0), Just(x1), app(ty_[], x2))
new_esEs11(Char(x0), Char(x1))
new_compare5(Double(x0, x1), Double(x2, x3))
new_ltEs19(x0, x1, app(ty_Maybe, x2))
new_esEs24(x0, x1, ty_Integer)
new_ltEs8(GT, EQ)
new_ltEs8(EQ, GT)
new_ltEs5(Just(x0), Just(x1), ty_Double)
new_esEs31(x0, x1, ty_Bool)
new_ltEs5(Just(x0), Just(x1), ty_Int)
new_compare28(x0, x1, True, x2, x3, x4)
new_lt19(x0, x1, ty_Double)
new_esEs24(x0, x1, ty_Int)
new_esEs6(Nothing, Nothing, x0)
new_esEs20(x0, x1, ty_Integer)
new_esEs22(x0, x1, ty_@0)
new_esEs6(Just(x0), Just(x1), ty_@0)
new_ltEs6(Right(x0), Right(x1), x2, ty_Bool)
new_lt19(x0, x1, ty_Int)
new_esEs5(Right(x0), Right(x1), x2, ty_Float)
new_ltEs20(x0, x1, ty_@0)
new_esEs21(x0, x1, app(ty_[], x2))
new_ltEs6(Left(x0), Left(x1), ty_Bool, x2)
new_esEs20(x0, x1, app(app(ty_Either, x2), x3))
new_esEs8(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_ltEs7(x0, x1)
new_ltEs6(Left(x0), Right(x1), x2, x3)
new_ltEs6(Right(x0), Left(x1), x2, x3)
new_esEs24(x0, x1, ty_Float)
new_ltEs20(x0, x1, ty_Double)
new_esEs25(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_esEs23(x0, x1, app(ty_[], x2))
new_esEs24(x0, x1, ty_Double)
new_compare([], :(x0, x1), x2)
new_esEs29(x0, x1, app(app(app(ty_@3, x2), x3), x4))
new_primEqInt(Pos(Zero), Pos(Zero))
new_lt19(x0, x1, ty_Ordering)
new_compare29(x0, x1, x2)
new_esEs22(x0, x1, app(ty_[], x2))
new_lt19(x0, x1, app(app(ty_Either, x2), x3))
new_esEs23(x0, x1, ty_Char)
new_esEs31(x0, x1, ty_Float)
new_esEs25(x0, x1, ty_Double)
new_esEs20(x0, x1, app(app(ty_@2, x2), x3))
new_primMulInt(Neg(x0), Pos(x1))
new_primMulInt(Pos(x0), Neg(x1))
new_esEs5(Right(x0), Right(x1), x2, app(app(ty_@2, x3), x4))
new_esEs23(x0, x1, app(app(ty_@2, x2), x3))
new_esEs21(x0, x1, ty_Double)
new_ltEs5(Just(x0), Just(x1), ty_Integer)
new_esEs8(x0, x1, ty_Integer)
new_ltEs16(False, False)
new_compare18(x0, x1, True)
new_compare27(x0, x1, False)
new_esEs21(x0, x1, app(app(ty_@2, x2), x3))
new_lt10(x0, x1, ty_Int)
new_esEs21(x0, x1, ty_@0)
new_ltEs12(x0, x1, x2)
new_primCmpNat0(Zero, Succ(x0))
new_ltEs4(x0, x1, x2)
new_esEs30(x0, x1, ty_Char)
new_esEs24(x0, x1, app(app(ty_@2, x2), x3))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs: